Pin Me

Seven Strategies for Successful Software Engineering: Part 1

written by: Danny Poo•edited by: J. F. Amprimoz•updated: 10/7/2008

Changes are inevitable in every software development project. Every good software engineer should pay close attention to ensuring software is designed to withstand change. We examine seven software engineering principles for designing and developing software applications.

  • slide 1 of 3

    Part 1: Rigor and Formality, and Separation of Concern

    A number of Software Engineering principles have been devised over the years to guide software developers in their quest to produce robust and maintainable software systems. These principles include:

    1. Rigor and Formality

    2. Separation of Concerns

    3. Modularity

    4. Abstraction

    5. Anticipation of Change

    6. Generality

    7. Incremental Development

  • slide 2 of 3

    Rigor and Formality

    Consider the ubiquitous traffic light system. It is one system that most people take for granted. It is always expected to turn green, amber, red, green, amber, red, etc. By observing this simple rule of green to go, amber to get ready to stop and red to stop, traffic flows smoothly. But, when the system fails, chaos prevails.

    Order at the traffic light junction comes about because of one reason: Drivers obey the rules - green to go, amber to get ready to stop and red to stop. When traffic lights go out of order, this rule becomes invalid; the intersection should be treated as an all way stop. Each driver is left on his/her own to decide when it is their turn and safe to cross the junction. The situation at the junction becomes informal and difficult, resulting in chaos.

    Software systems development is very much like the situation at a traffic light junction. Many people of differing skill-sets and interests are involved in the process. Without set rules, each developer imposes his/her own interest on the project. When problems occur, they become difficult to resolve.

    The rigor of a software development project is achieved by setting rules into the process. Every person involved in the project has to observe the rules. With rigor, a project can carry on smoothly without hindrances. However, when projects are lacking in rigor, they are doomed to run into problems and fail, resulting in unreliable products, high costs, and time overrun.

    There are various degrees of rigor. The highest level of rigor is formality – a situation where software systems can be verified by mathematical laws. Automated testing and error removals are possible. Much research has gone into applying formality in software development. A branch of Software Engineering research known as Formal Methods has been well debated and discussed in numerous Software Engineering conferences. However, practical application of formal methods has been limited.

  • slide 3 of 3

    Separation of Concerns

    “Divide and Conquer” is a phrase you might have heard before. This phrase (in Latin divide et impera) reflects an approach practiced by the ancient Romans in their conquest of other nations – divide and isolate the nations, then conquer them one by one. When this approach is applied to software development, the same happens – divide a larger problem into multiple smaller sub-problems; solve the sub-problems individually and the larger problem is said to be solved.

    “Separation of concerns” is similar to “Divide and Conquer” in that it allows us to deal with different aspects of a problem and focus on each separately. There are many areas of concerns in software development. Examples include software functionalities, user interface design, hardware configuration, software applications, space and time efficiency, team organization and structure, design strategies, control procedures, error handling, and budgetary matters. By separating the multiple concerns and focusing on them individually, the inherent complexity of a large-scale software project can be greatly reduced and better managed. Separation of concerns has been known to enhance the visibility, understandability and maintainability of software systems.

    In our next article we will explain Modularity and Abstraction as Software Engineering Principles.

Software Engineering Principles

Changes are inevitable in every software development project. Every good software engineer should pay close attention to ensuring software is designed to withstand changes. We examine seven software engineering principles for designing and developing software applications.
  1. Seven Strategies for Successful Software Engineering: Part 1
  2. Seven Strategies for Successful Software Engineering: Part 2
  3. Seven Strategies for Successful Software Engineering: Part 3


Popular Pages



More Info