What the history of process models tells us about agile development

I am delighted to be able to repeat a guest post this week from Dr. Andrea Herrmann to publish. This time it's about the history of process models. I had to smile while reading, as Andrea pointed out that agility is much older than previously assumed, which is why I have already commented here had.
But before we get to the article, here's a call from Andrea for a non-commercial survey on agility in practice. The University of Magdeburg is conducting this survey on the spread and use of agile software development in the software industry in German-speaking countries. It takes about 10 minutes to answer the questions. The survey is anonymous, results can be sent on request
To the survey "Agility in practice" >>
Guest article by Dr. Andrea Herrmann
On May 22, 2017, I gave a talk at the Karlsruhe Developer Days in Karlsruhe. Pecha Kucha Presentation on the history of process models. (This was a fixed time presentation with 20 slides, 20 seconds per slide). I had read typewritten articles on this historical archive research, which mentioned names of operating systems that only run in computer museums and amounts of memory that are now exceeded by a wristwatch. From a software engineering perspective, the problems have remained the same: Our ability to master technical complexity is lagging behind complexity. Or, conversely, we are probably always producing slightly more complex software than we can reliably produce without errors with our resources. That's the only way to get to the moon, I suppose.
To summarize, my research revealed that
- that agility is not as new as people think and
- that even in the past, people did not believe that the waterfall approach would work. The waterfall model was first mentioned by Benington (1956) and Royce (1970). But Benington suggested the waterfall model as potentially helpful after a project had gone wrong. While Royce, based on his project experience, could say for sure that the waterfall model does not work. He suggested an iterative approach with prototypes.
Royce wrote back in 1970 that waterfall doesn't work and that an iterative approach with prototypes is better. [tweetthis]1970: Iterative approach with prototypes is better than waterfall[/tweetthis].
So it was by no means the case that people used to believe that the waterfall would work and that everyone only worked according to it. Even back then, iterative procedures were already known. It is also not the case that in the 90s, completely new process models suddenly emerged through ingenious creation, revolutionizing the software engineering world with an agile manifesto from below.
Instead, waterfall and iterative, lightweight (i.e. agile) approaches have always both existed, sometimes more or less praised by the specialist literature. In the 1980s, however, criticism of the waterfall approach intensified. Standardized agility as we know it today, in particular Scrum and XP, were actually developed in the 90s. However, these had predecessors such as the now almost completely forgotten Rapid Application Development (RAD). This already looked very, very similar to today's Scrum! In the 90s, the waterfall approach was also first really standardized, e.g. in the form of V-Modell XT, and the heavyweight Rational Unified Process RUP. The 90s were therefore an era of standardization of process models.
Rapid Application Development from the 80s already looked very similar to today's Scrum! [tweetthis]Rapid Application Development from the 80s already looked very similar to today's Scrum![/tweetthis]
Agile methods then experienced a hype and gained market share. However, around half of all projects are still carried out according to the phase model. The other half is not agile, as there are also projects without an explicit process model.
The current state of software engineering is such that Scrum is being pushed to its limits and modified for various application areas. This includes areas for which it was not originally designed, such as large and distributed teams, or the development of safety-critical software with extensive documentation requirements. In addition, the not-quite-agile Scaled Agile Framework (SAFe) was developed.
I predict greater diversity in the future. There will be non-agile process models that call themselves agile for marketing reasons, every company will develop its own "ScrumBut" and so on. So hopefully we will still find out how to develop error-free software!
Photo by Les Anderson on Unsplash





