This is an old revision of the document!
Table of Contents
Principles of Software Engineering
Mithat Konar
July 23, 2012
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 and other shareholders
- 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
- Separation of concerns
- Modularity
- Abstraction
- Anticipation of change
- Generality
- Incremantality
The principles
- Rigor and formality ☜
- Separation of concerns
- Modularity
- Abstraction
- Anticipation of change
- Generality
- Incremantality
Rigor and formality
- rigor: the quality or state of being very exact, careful, or strict.2
- formality: the highest degree of rigor
- Often based on mathematical/logical laws
- Different projects/parts require more or less rigor/formality
- High criticallity → high rigor/formality
- Tools include natural language, formal languages
Rigor and formality
- Impacts software qualities of:
- reliability
- verifiability
- maintainability
- reusability
- portability
- understandability
- interoperability
- reusability
The principles
- Rigor and formality
- Separation of concerns ☜
- Modularity
- Abstraction
- Anticipation of change
- Generality
- Incremantality
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
The principles
- Rigor and formality
- Separation of concerns
- Modularity ☜
- Abstraction
- Anticipation of change
- Generality
- Incremantality
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
The principles
- Rigor and formality
- Separation of concerns
- Modularity
- Abstraction ☜
- Anticipation of change
- Generality
- Incremantality
Abstraction
- In general use, abstraction means the process of considering something “apart from application to or association with a particular instance.”3
- 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
- …
The principles
- Rigor and formality
- Separation of concerns
- Modularity
- Abstraction
- Anticipation of change ☜
- Generality
- Incremantality
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.
The principles
- Rigor and formality
- Separation of concerns
- Modularity
- Abstraction
- Anticipation of change
- Generality ☜
- Incremantality
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:
- Invent a wheel and then use that to build the oxcart wheel.
- Don't re-invent the wheel in the first place.
- General problem might be easier to solve (or not).
- Supports quality of reuse
The principles
- Rigor and formality
- Separation of concerns
- Modularity
- Abstraction
- Anticipation of change
- Generality
- Incremantality ☜
Incremantality
- A journey of a thousand miles begins with a single step. —Lao-tzu mistranslation4
- Development proceeds in a stepwise fashion (i.e., in increments).
- 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.
- Software engineering is:
- a new field and subject to change
- made by humans for humans.
- Your contemplations and considerations are crucial.
Endnotes
1Ghezzi, Carlo, Mehdi Jazayeri, and Dino Mandrioli. “Software Engineering Principles.” In Fundamentals of Software Engineering. 2nd ed. Upper Saddle River, N.J.: Prentice Hall, 2003. 42.
2“Merriam-Webster's Learner's Dictionary.” Merriam-Webster's Learner's Dictionary. http://www.learnersdictionary.com/search/rigor (accessed July 23, 2012).
Endnotes
3“Abstracting - Definition and More from the Free Merriam-Webster Dictionary.” Dictionary and Thesaurus - Merriam-Webster Online. http://www.merriam-webster.com/dictionary/abstracting?show=0&t=1343046707 (accessed July 23, 2012).
4“Quote Details: Lao-tzu: A journey of a… - The Quotations Page.” Quotes and Famous Sayings - The Quotations Page. http://www.quotationspage.com/quote/24004.html (accessed July 23, 2012).
~
Copyright ©2012 Mithat Konar