The Evolution of Software Management Techniques

Last week we’ve delved into the history of how complex software evolved. In this article, we’re going to talk about how management techniques have come in support and adapted to the changing needs of software development.

As technologies evolved, management paradigms also emerged organically as a response to the increasing complexity of software development. Project managers at important companies and startups alike, needed methods with which to better organize their teams in productive ways.

Software development approaches can be lumped into two main eras: predictive and adaptive. We will take the time in elaborating both of them, as they are linked. This chapter has been influenced by a great infographic on the history of software development methodologies, created by Intetics.

The Predictive Era

The predictive era spanned across 40 years, from 1950 to 1990. This was the age in which software was planned ahead, with each step being necessary to be completed before the next one starts.

Usually, there was no reverting back to a previous step in the process. Each step was to be completed first, then teams used to move to the next step in the process. After each step was finished, the software was deployed. 

The first major software development approach of the predictive era was the structured programming paradigm of the ‘50s. It talked about how four structured control flow constructs were used to provide a more clear and qualitative software development process:

• Selection (if/then/else)
• Repetition (while and for)
• Block structures (code put together in blocks of code)
• Subroutines (a code routine that can be used inside another program)

These control constructs marked the philosophy behind software development in the 1950s.

Moving on, we get to Waterfall, which was normalized in the 1960s. It’s important to note that some older software management paradigms did not become obsolete. Some of them are still being used today.

The fact that we present them here exhibits the evolution and the linking property that one paradigm derived from its predecessor, not that it became obsolete because of it.

Waterfall presented a more streamlined, linear and sequential flow of the development process. Each step of the Waterfall paradigm was a drop in the grand scheme of things:

• Requirements – an initial document would be drafted with what the software needed to achieve
• Design – based on the requirements from the previous step, the architecture gets set and also (if applicable) the visual design of the software
• Implementation – the actual coding part
• Verification – testing the implementation and verifying for bugs and other malfunction
• Maintenance – perpetual maintenance of the software

There is also an extension of Waterfall, called the V-Model paradigm (the late 1980s). In the V-Model paradigm, the implementation phase resembles a V shape process, where each line of the V encapsulates steps from the development process. 

Moving on from the Waterfall paradigm, we reach the Iterative & Incremental approach. The I&I approach helps developers by providing them with repeated cycles and smaller steps to achieve (i.e. Iterative and Incremental). Think of it as a loop:

• Initial planning 
• Planning // loop start
• Requirements             
• Analysis & Design      
• Implementation        
• Testing                       
• Evaluation // loop end
• Deployment                  

When decided, the project jumps to deployment. At first sight, you might say: “But this looks just like Agile”. Well, not quite. We will get to that soon.

Reaching into the paradigms of the 1980s, we get to Prototyping, which is basically the same across all the different flavors of engineering, such as mechanical and manufacturing.

You can think of it as the equivalent of an MVP (Minimum Viable Product) of today. You first think of the basic requirements of the product. Then, you start developing the product.

After you’re done developing, a review ensues. Clients, developers and usually the stakeholders pitch in to gather feedback on the prototype. With the feedback in hand, the prototype gets updated and integrated with the new feedback.

Finally, we reach the last paradigm of the predictive era: the Spiral model, which combines different attributes from existing models such as Waterfall, incremental and evolutionary Prototyping (building on top of each prototype).

Imagine that we have a spiral, and at the center of it we have conceptual models of the requirements, operations, and requirements planning. As we move along the spiral to the right, we reach the first prototype, then before reaching the second prototype we enact and validate the fundamental requirements and start the development.

Before reaching the third and last prototype (called the operational prototype), we go through with familiar processes:

• Design
• Code
• Integration
• Test
• Release

The spiral is divided into four quadrants, each of them encapsulating and grouping together processes of the same nature.

The paradigms presented here, mark 40 years of software development management evolution, but the adaptive era was just about to start.

The gist of this article is a fragment from “Managing complex software”, the third chapter of our book called From A to App Success: How to turn ideas into apps that make a difference.

The rest of the chapter gets into the second major phase of software management paradigms, also known as the Adaptive Era. You can download the book for free by accessing our website here.