century:principles_of_software_engineering
This is an old revision of the document!
Table of Contents
Principles of Software Engineering
Mithat Konar
Adapted from
- Ghezzi, Carlo, Mehdi Jazayeri, and Dino Mandrioli. “Software Engineering Principles.” In Fundamentals of Software Engineering. 2nd ed. Upper Saddle River, N.J.: Prentice Hall, 2003. 41-66.
Introduction
- Motivation
- Most real-world problems are:
- Complex, difficult to decompose
- Involve a number of developers
- Evolve over time
- Software engineering attempts to provide developers with strategies to manage this.
- “How do you build big projects?”
Introduction
- Product: “What it is,” and “The code you write.”
- Process: How you got there.
- Both are important.
Introduction
The principles
- Rigor and formality
- Modularity
- Separation of concerns
- Abstraction
- Anticipation of change
- Generality
- Incremantality
Rigor and formality
- rigor: the quality or state of being very exact, careful, or strict1)
- formality: the highest degree of rigor
- Often based on mathematical/logical laws
- Tools include natural language, formal languages
- Different projects/parts require more or less rigor/formality
- High criticallity → high rigor/formality
Rigor and formality
- Impacts s/w qualities of:
- reliability
- verifiability
- maintainability
- reusability
- portability
- understandability
- interoperability
- Impacts process quality of reusability
Separation of concerns
- Features and responsibilities should overlap as little as possible.
- Minimizes interdependence
- Increases resusabilty
- Can be applied to product and process
- Example: A lamp is not a toaster.
- Changing a light bulb doesn't break toasting.
- If you need a lamp someplace, you don't have to get a toaster as well.
Separation of concerns
- Another example: the Web
- “Web 2.0+”:
- Content/semantics: XHTML
- Presentation: CSS
- Behavior: Javascript
Modularity
- Divide the system into smaller modules
- Typically results it a tree of modules and submodules
- Decomposition: recursively subdividing the system
- “Divide and conquer”
- top-down
- Composition: building up from completed parts
- Legos
- bottom up
Modularity
- Benefits
- Facilitates separation of concerns
- Supports anticipation of change
- Enhances quality of understandability
Abstraction
- Abstraction in general use means the act or process “[considering] apart from application to or association with a particular instance.”2)
- In S/W Engineering, abstraction means wrapping a concept such that it:
- Expresses the concept only in terms of what is relevant.
- Shields the user from everything that's not relevant.
- (i.e., building models)
- Examples:
- What is a ball?
- Functions
Abstraction
- Humans are powerful abstractors.
- Abstraction is at the heart of computing.
- Applied to:
- Hardware
- Programming languages
- Program design
- Programming process
- …
Anticipation of change
- Almost all development projects change
- while the project is being developed,
- after release.
- Process and code should be designed to support evolution.
Generality
- Often, a problem you work on is a more specific version of a more general problem.
- Work with solution based on more general problem.
- If you need to invent an oxcart wheel, first invent a wheel and use that to build your oxcart wheel.
- Don't re-invent the wheel if you don't need to.
- General problem might be easier to solve (or not).
- Supports quality of reuse.
Incremantality
- Development proceeds in a stepwise fashion (i.e., in increments)
- Strategies:
- Deliver subsets of a system early to get early feedback
- Deliver prototype of the system and incrementally add effort to turn it into product
- Implement functionality, then tune performance
- “Iterative refinement”
- Supports anticipation of change
- Example: Adium's commit history
Concluding remarks
- Different methodologies emphasize different combinations of principles
- Conflicts among principles may arise.
- New field and subject to change.
- Made by humans for humans.
- Your contemplations and considerations are crucial.
Endnotes
1Microsoft, Inc. “Version Class (System).” MSDN | Microsoft Development, Subscriptions, Resources, and More. http://msdn.microsoft.com/en-us/library/system.version.aspx#Y171 (accessed March 9, 2011).
2Ibid. Emphasis added.
This content is Copyright © 2012 Mithat Konar
century/principles_of_software_engineering.1343058541.txt.gz · Last modified: 2012/07/23 15:49 by mithat