Rigor and formality software engineering

Software Engineering environments are found anywhere there are multiple stakeholders and technical resources must coordinate their efforts to achieve their goals. It is a more formal and scientific endeavor which can only be successfully performed with the formality and rigor of the other engineering disciplines such as physical and chemical engineering.

Because software development is a creative activity, there is an inherent tendency toward informal ad hoc techniques in software specification, design and coding. While such development practices can, statistically speaking, be successful in some large, complex projects, the need for rigor and formality will become apparent over time. Eventually the teams members begin to burn-out, the projects become too large to properly manage with an informal style, deliverables begin to slip, requirements are skipped or misinterpreted, code debt is incurred and overall product quality suffers.

Predictably executing on large-scale projects requires significant effort. Small software development environments which start out with one or two programmers can often utilize software programming practices for the organizations initial projects. Once that organization grows, however, those same practices begin to generate more problems than they solve.

While it may seem that those practices are speeding the development, the quality of that product begins to suffer. Coordination between the increased numbers of participants and stakeholders tends to overwhelm the team and less time is spent productively.

Communicating all the needs and expectations becomes difficult and the variables of each project increase greatly making success more difficult to reproduce and failure more difficult to avoid. Code debt and software defects continues to increase until the code base becomes unmanageable. It begins to cost more to maintain and evolve the code and ultimately the margins begin to shrink as software productivity declines. This is when software programming must evolve into Software Engineering.

Software development is a creative activity but is must be practiced systematically and with discipline. Rigor is a necessary complement to creativity that increases confidence in the results of development activities. Creativity often leads to imprecision and inaccuracy and software development can tolerate neither.

The informal approach to software development is contrary to good Software Engineering practice. Software Engineering involves many people of differing skill-sets, goals and interests. When problems occur, they become difficult to resolve and often result in unproductive conflicts. Software development needs a set of rules which allow participants to divide the workload without losing track of the work to be performed.

The rigor of a software development process is the level of discipline the process exhibits often through governance; it is the rules which direct how the process is executed. With rigor, a process can carry on smoothly without hindrances but without it projects invariably stray into problems resulting in unreliable products, high costs, missed schedules and even project failure. Rigor helps to produce products with higher reliability, greater quality while controlling costs and meeting expectations.

Of equal importance is rigor enables repeatability and allows teams to avoid problems experienced in past projects. The cost of activities early in the projects life seems high at that point in time but is insignificant when compared to the costs incurred in later phases. Time spent in clarifying requirements is minuscule when compared to the cost of re-designing a product to accommodate a forgotten requirement.

Consider building a system which is required to encrypt all data in transit and then trying to retrofit such encryption requirements into a existing system a year after it was released. All software development projects can benefit from some set of rules to follow to ensure important requirements are not missed or undervalued. Some level of rigor must be applied in requirements gathering and analysis to ensure success and to avoid future costs of issue remediation.

There are varying degrees of rigor from completely ad hoc to the highest level of formality. A formal practice is where software systems can be verified by mathematical laws.

Automated testing and error removals are not only possible but one of the benefits of adopting formal rigor in software development. 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. 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.

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. 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. Page content. 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.