Principles of Software Engineering

Mithat Konar
July 24, 2012

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.

• 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?”

• Product: “What it is,” and “The code you write.”
• Process: How you got there
• Both are important

↑
changes rapidly
changes slowly
↓

• Rigor and formality
• Separation of concerns
• Modularity
• Abstraction
• Anticipation of change
• Generality
• Incremantality

• Rigor and formality
• Separation of concerns
• Modularity
• Abstraction
• Anticipation of change
• Generality
• Incremantality

• rigor: the quality or state of being very exact, careful, or strict.²
• formality: the highest degree of rigor
  • Often based on mathematical/logical laws
• Different projects/parts require more or less rigor/formality
  • High criticality → high rigor/formality
• Tools include natural language, formal languages

• Impacts software qualities of:
  • reliability
  • verifiability
  • maintainability
  • reusability
  • portability
  • understandability
  • interoperability
  • reusability

• Rigor and formality
• Separation of concerns
• Modularity
• Abstraction
• Anticipation of change
• Generality
• Incremantality

• 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.

• Another example: the Web
  • “Web 1.0”: content, presentation, behavior comingled in same HTML code

    <a href="foo.html"
    target="_foowindow"><font-face="verdana"
    color="green">Click me!</font></a>

  • “Web 2.0+”:
    • Content/semantics: XHTML
    • Presentation: CSS
    • Behavior: Javascript
    • example code

• Rigor and formality
• Separation of concerns
• Modularity
• Abstraction
• Anticipation of change
• Generality
• Incremantality

• Division of the system into smaller modules
• Decomposition: recursively subdividing the system
  • “Divide and conquer”
  • top-down
• Composition: building up from completed parts
  • Legos
  • bottom up

• Benefits:
  • Facilitates separation of concerns
  • Supports anticipation of change
  • Enhances quality of understandability

• Rigor and formality
• Separation of concerns
• Modularity
• Abstraction
• Anticipation of change
• Generality
• Incremantality

• In general use: considering something “apart from application to or association with a particular instance.”³
• In S/W Engineering: 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

• Humans are powerful abstractors.
• Abstraction is at the heart of computing.
• Applied to:
  • Hardware
  • Programming languages
  • Program design
  • Programming process
  • …

• Rigor and formality
• Separation of concerns
• Modularity
• Abstraction
• Anticipation of change
• Generality
• Incremantality

• Almost all development projects change
  • while the project is being developed,
  • after release.
• Process and code should be designed to support evolution.

• Rigor and formality
• Separation of concerns
• Modularity
• Abstraction
• Anticipation of change
• Generality
• Incremantality

• 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

• Rigor and formality
• Separation of concerns
• Modularity
• Abstraction
• Anticipation of change
• Generality
• Incremantality

• A journey of a thousand miles begins with a single step. —Lao-tzu mistranslation⁴
• Development proceeds in a stepwise fashion (i.e., in increments).
  • “Iterative refinement”
  • 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
• Supports anticipation of change
• Example: Adium's commit history

• 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 contributions are crucial.

¹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. 42.

²“Merriam-Webster's Learner's Dictionary.” Merriam-Webster's Learner's Dictionary. http://www.learnersdictionary.com/search/rigor (accessed July 23, 2012).

³“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).

⁴“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