"Every time I read about the Waterfall Model, I think to myself: I'm sure there must be companies out there that have tried this approach, but I have a hard time believing some software book would seriously propose it as the best way to write software"
I've been on software development projects (the final product would be source delivered to the customer) where the waterfall model was explicitly specified, with the whole design- and implementation phase based on this, with milestones where each step of the waterfall would be delivered and checked by the customer. This was particularly prevalent back in the eighties and beginning of the nineties. It's as real as can be, it did exist.
Obviously developers couldn't follow that 100%, so there would be some amount of back-designing an earlier stage, but if it wasn't 100% it was very close in practice too.
Agreed! There's waterfall & agile and dogmatic & pragmatic. I've never worked on a dogmatic waterfall project but have worked on several dogmatic agile projects (that made me strongly wish I wasn't).
In the pragmatic waterfall projects I worked on, during the Design phase there was still coding (by juniors, on submodules with obvious predictable designs as well as some refactoring (yes!)) and testing going on. It's just that in the Design phase it was understood any coding might need to change. In the Code/Build phase, design changes were still possible as issues were discovered (with maybe just a little more resistance). In short, we were very pragmatic about it. Much more so than with the Agile religion.
The Design phase focused on designing but not exclusively so. The Build phase focused on building but not exclusively so. Humans were building things long before Agile came along. The pyramids were probably built with a pragmatic waterfall method, not an agile method (pragmatic or dogmatic).
Hardware development is almost exclusively Pragmatic Waterfall. It's pretty much a requirement. Lots of reasons. Too many to list here (it would probably not be useful).
As a software dev for hardware companies, most of my life, I splashed in a lot of waterfalls.
One reason that waterfall method I mentioned actually managed to produce a working system was that the customer (together with all the companies working on the project) put extensive effort into the requirements phase. Working on the requirements and removing requirement conflicts (a very common thing), understanding of requirements, feasibility of requirements etc. etc., and, at the final stage, a week-long meeting with everyone (customer, companies) to work out the last kinks. Only after that did the next phase start: Creating software requirements from the system requirements, and from there, an architecture and so on. And, as this was something involving many companies in many countries and even continents, having everyone on the same page was essential. And it did work. Of course in the years following the project there would be bugs etc, but not fatal ones (which are typically caused by errors in the requirements- and architecture phases).
(We had several projects of the type above, and those which had more problems were those were the requirements phase wasn't as extensive)
EditAdd: Just to be clear - I don't think the pure waterfall model is the best way to work. However I did learn a lot from it, particularly how important requirements are. And the forth-and-back-and-forth-and-back on this which can happen in Agile projects isn't really the solution either.
It works if your client knows and can articulate exactly what needs to be made.
I imagine that was more common in the 80s and early 90s when most people working in computer land were more tech savvy (relatively) than your average project manager today. And the market was less “get it out there asap” than it is today.
Same here. Just 10 years ago I had the displeasure of working on such a project. Months and months of upfront specification work. The UX was defined in full separately from the UI. All the DB models built in one go. Every Gantt cascade one could imagine. Horizontal slice by horizontal slice. The system was to be fully integrated at the very end, followed by a few weeks of QA.
If anyone doubts that waterfall was the dominant approach to development and project management, just go back to the tools of the times, like Microsoft Project. Gantt charts were the unquestioned way you managed a project.
It was definitely the dominant conceptual approach, but I think it's an open question how much it was actually followed versus just being the lies everybody agreed to tell the executive caste.
One way I've weaned people off waterfall approaches is just to tell them yes, of course that's what we're doing, but to make it extra safe, we'll produce software early and often so you can see progress. Then eventually I'll slip in getting users to try it, just for "testing". And then getting it deployed early, for more "testing". The smart ones get engaged in this process, using it to making things better than the initial conceptions. They may produce waterfall documents for a while, especially if they need to pacify higher ups. But often they'll just forget. I think them GANTT charts and the like were always a ritual to get them feelings of control, and they stop doing that work once they have actual control.
So I suspect a lot of the nominal waterfall projects of yore were similarly made to work by developers just doing the right thing in quiet ways while saying, "Oh, that's 90% complete for sure. Mark it on your chart!"
Something similar happened to flow charts. They get unreadable after a few tens of LOC, but the managers required them. So people dutifully shipped tons of paper upstairs, and nobody ever read them. Then they were drawn after the source was written, instead of before. Then a computer program generated them straight from the source code. Then they stopped printing them, storing them on disk instead. Then the flow chart generator broke, and nobody noticed the write-only documentation was missing. Finally, some manager got the genius idea to speed up the process by not requiring flow charts anymore.
This kinda reminds me of a middle school English teacher I had who insisted on receiving both a rough draft and (a couple days later) a final draft, which had to be different, because there had to be at least some grammar/spelling mistakes in the first draft.
I was a kid who didn't make grammar/spelling mistakes. I'd just write up the paper, insert two or three errors, submit it, and then a couple days later submit the original version.
Hmm, here as well. But then would reorganize the sentences, and add details, where I think the most value of another draft is. Fixing spelling mistakes never entered my mind.
>It was definitely the dominant conceptual approach, but I think it's an open question how much it was actually followed versus just being the lies everybody agreed to tell the executive caste.
Its funny because that would the inverse of the current situation where exec proclaims their company is agile to external observers and potential hires, but the de facto regime could be anything
Great point. And in those faux-Agile environments, you'll definitely sometimes find people just doing the right thing and then finding the right way to lie to JIRA about it.
One company I worked with we switch over from waterfall to agile. The 'guardian' of the rooms of paperwork was so happy when she could bin 2 rooms full of filing cabinets overflowing with designs no one really followed. Took her about a week to clear it all out. Hundreds of rolls of gantt charts dumped into a recycle dumpster. Basically we stopped pretending we were not redesigning everything as we went along.
I worked professionally from the late 90s. We used Gantt, but it was always for spiral or unified process. We were always told to avoid waterfall (as there’s a natural tendency to go that way) and always include feedback loops.
There's a reason why construction and other projects that require coordinating with external parties rely on Microsoft project so much.
I'm on a project now trying to manage external customer cutovers and integrations using JIRA and its a dumpster fire.
A proper project plan with deadlines, lead times, resources etc would solve 99% of the problems.
Its just non stop crisis "oh we forgot to get get change submitted on time" - "oh this customer can't migrate until date x" - "oh this test environment is down for scheduled rebuild on days xyz" - all can easily be tracked to automatically calculate timelines.
Agile is fine at a macro level, but it needs to feed into a better system for real world dependencies and deadlines.
We use extreme waterfall. All the disadvantages of agile and waterfall in one process. Nothing gets to production due to meetings so the customers are happy we aren’t fucking anything up.
Of course there's a range of transitional states between waterfall and [whatever miracle cure is in vogue today]. Like all historical revisionists, today's techies like to impugn the old and laud the new. ('How could they have been so clueless?')
Fact is, long-lived products, esp. from BigCorps, and esp. those in heavily regulated spaces like medicine and transportation always have and always will spend a lot more time and effort on design and process than will ephemeral products and services from startups. My software career started ca. 1990 just as waterfall was evolving into the 'Spiral' iterative software model, which since has been rebadged and remorphed several times into today's 'agile' and 'test-driven' gift from god. However in the real world, makers of every S/W product inevitably must adapt their actual development process to suit the lifecycle needs of their product and customer, in ways that scrum can't serve. Often the best way to reduce technical debt is to increase investment design and testing. And taken to NASA-like limits of fault-tolerance and reliability, that can take you all the way back to waterfall.
So like a waterfall, but the day to day is connected by little bits of agile? You end up at the bottom of the waterfall, but by taking a bunch of much smaller falls instead?
Have you considered calling it Rapids development? You will sell a million books or whatever, just on the name.
This. Some products are platforms with thousands of functionalities all interlinked in a uniform data model, with similar but specific behavior expected for all modules of the platform.For instance, a Core Banking System, or OMS in Telcos. And since we all get paychecks, it seems to work.
Building such an product in agile was often tried and failed in the past decade. You need common data structures and routines that a few thousand developers can all expect to find ready further down the line. Like the Oregon Trail game, you launch all workstreams in different moments and expect them to converge at the finish line.
I think “100% waterfall” was ditched in the early 90s, for all the known reasons, with smaller cycles of releases becoming the norm. But still the hard thinking, laying down the key mechanisms of a platform was heavily thought out early on.
I think all criticism is a bit unfair, as agile is also an infinite source of cock ups, mediocrity and dead ends just as waterfall. There is a space for each approach, and bottom line, the right people will make all the difference. But that’s also why it’s important to learn and respect both approaches…
The whole strawman/dichotomy you see with Agile and Waterfall boils down to needing both flexibility and vision for large projects, and each fails at one of these.
How much do you think it was an artifact of the time? Agile relies on it being fast/cheap/easy to ship and deploy incremental changes. I have a hard time believing that to be the case in the 80s. When planning and designing on paper is cheap in comparison, it makes sense to me that is the development method people used.
> How much do you think it was an artifact of the time?
I was a software engineer in the 90s at a small company (15 people) doing simulation development for the UK Ministry of Defence. We had two distinct software development processes, which were waterfall and a form of rapid development known as the Dynamic Software Development Method (DSDM). (I threw away the manuals years ago so can’t give more info).
The company directors came from an aerospace background so had a very strong software quality focus. Many of our contracts specified waterfall and our project artefacts reflected that – user requirements docs, system requirements, architectural design, detailed design, integration test plans, system tests, acceptance tests, etc etc. Coding happened somewhere in the middle. It did work, sort of, in situations where the customers knew what they wanted, and we mutually understood it. Which was quite often the case, for our regular customers on projects that were extending existing systems.
We trialled DSDM for projects where the customer said ‘prototype’ and I liked it. It lacked the onerous agile / scrum boilerplate and IIRC was based around loosely specified timeboxes and relied on having ‘intelligent customers’ who were prepared to be flexible in terms of what they got at the end.
The need for DSDM was motivated by a project that failed badly (not with the MOD) because the customers said ‘here are our requirements for this prototype system, don’t come back until you have finished and tested it’. Needless to say the result wasn’t what they expected, even though all of the requirements had been, on paper, met.
But for any development where specific technical outcomes were necessary (e.g. a maths module), waterfall would usually be used.
I got a course at Oracle on DSDM RAD (rapid application development) and worked on a project with it. The 4GL tooling used at Oracle were no good fit, but back then also Oracle was moving up to 3GL tools like JDeveloper. And they thought using RAD was good fit.
Key what I remember was time boxing. And much less religious stance than Agile. But back then it was normal to have different people doing functional designs, technical designs, database design (also in two levels) and business process design of sorts. I guess it took a while for these people to realise they had to be Agile digital transformers.
And I guess it also did not help the DSDM also certified people on the waterfall methodology.
I think it was more about the corporate culture which dictated that people had a plan and stick to it.
It's still the case in many trades. You don't build a house or a bridge the Agile way for instance.
IMHO Agile got a lot more prevalent because the planning phase became more and more onerous to have any reliability, and management was tired of paying upfront for it. I steady they could get a more regular billing (in particular when dealing with consulting companies) with reports of stuff allegedly shipped, instead of six months of "we're planning very hard, just trust us". Whether the end result matched what they needed/wanted to build being another story.
I know many companies that had an official Waterfall cycle, while actually working on something more granularly shipped with many phases of prototyping. And they didn't move to Agile either, just stopped calling their process anything and went on doing whatever felt right.
I think it was an artifact of applying physical construction project concepts to building software.
If you're building a house, or something bigger, you don't just start nailing lumber together. You have a blueprint. Pretty detailed, and it uses industry-standard terms and markup. Any builder can take it and use it to construct the building. It has the dimensions and specifications for the foundation and all the rooms. It has considered where the rooms are, which walls are load bearing, where the staircases and HVAC and plumbing and electrical runs are, where the windows and doors are, pretty much everything. An engineer has signed off on the overall design as being safe and meeting all the applicable codes. You can order a list of supplies based on this plan and you'll be within a few percent of what you actually use.
Some small changes were allowed. You could change finish details like what style of cabinets or trim or door knobs would be used. But you could not really approach the builder once the framing was complete and say actually I wanted the living room over there and the bedrooms over here and also I want to add a third storey. You also didn't build one bedroom, and then based on that experience extrapolate the design for the next one, and then apply that to building the kitchen, and so on. It was all done up front.
People, especially people who were used to managing physical projects, thought that with the same level of planning, and the same approach to management, the same results could be achieved in software projects.
At that time the waterfall model method was one solution to the problem of software quality. Other methods hadn't yet been developed (or at least not become well known yet), and waterfall was in use by the industry (not everywhere though - re sibling comment). The customer I mentioned was huge and lots of companies in lots of European countries, and overseas too had development contracts which demanded this process to be used. And the results were actually good, even though the process was heavy. That didn't mean that it couldn't be improved on, and that did happen later, with more agile-like (though not "Agile") methods modifying the approach.
I find agile passive aggressive because the consensus is built under duress. I prefer a well reasoned approach. I can understand agile process in between waterfall milestones.
I can even support an agile process to create waterfall process.
Developers are still constrained by process, and it's their fault.
In every single company I have worked, the process always took priority. It's made even worse where you have ISO 9001 compliance where every god damn thing in the company is locked into a "process." Process over people, period. Coporo-managers can't get it out of their head.
When all you have ever done is "the process" it looks perfectly sane. To teams that can produce a POC and basically get to market on their own domain knowledge, it looks ridiculous. Making developers wait for requirements instead of inventing them on the fly is incredibly slow and smothers nearly all innovation.
Why risk making your product look like your convoluted communication and political structures? The entire point of agile was lost on the influx of bodies to the industry.
Form a "skunk works" team and shield them. Make a big show of how their success came despite having zero fucking process. Jira is for maintenance.
> In every single company I have worked, the process always took priority.
If process (or freedom from process) is important to you, you need to make it a priority when you're interviewing. May depend on what industry you work in, of course, some industries don't have any cowboys.
That said, I like my cowboy jobs with a little bit of process. What's deployed in production should be reflected in source control, but I'm not a stickler for which comes first. A change notification should be posted before production is changed, but if you have separate push and load steps, you can push before you notify (if pushing takes a while, it's good pipelining to use the push time to compose your change notice). Changelogs usually shouldn't be 'bugfixes' or 'latest', but 'fixing' is appropriate for a close in time followup. That's process, even if an ISO compliance officer would lose their mind.
That's why it's your fault, because you won't make decisions. You feel like there are rules and guardrails constraining you and bringing order to society but it is not so. If you envision the reality and live it, then it will manifest. Some people thinks this means being forceful and demanding. Just the opposite.
Then again, I doubt the company has a reward structure in place that even makes the mental energy worth expending.
If you aren't on the way up, then you are on the way out.
I think waterfall and waterfall-ish development is more prevalent in government contracting. You aren't building for yourself, you're building for a single external customer, and you have to build both the functionality and the interfaces that they want.
And I note that government contracting was probably a bigger fraction of all software engineering in the 1980s than it is today. (Still more in the 1960s.)
So, yes, it was real. It is mercifully less prevalent than it was.
In those days, having in-house competence to do the coding was very rare. With each step being much more connected to a specific area of competence. Hollywoods image of programmers was that they must not be seen anywhere near a customer.
This led to silos, where design was done by one group of people in the company, then sent to a third party contractor for a fixed scope and price.
This naturally creates a waterfall and when everybody just sees their own silo from inside, nobody questioned the big picture, nor that their own design would be flawed from the beginning. Until the product came back, not at all working as desired.
The biggest improvement today is that teams have much higher autonomy within their fully vertically integrated responsibilities. With wider areas of competence covered within a single team, or even a single person. As such, iterating and focusing on what is most important become more natural.
> with milestones where each step of the waterfall would be delivered and checked by the customer
I think this is one of the things that don't explicitly follow the waterfall diagram as presented and criticized though. You're delivering smaller units of work here and I presume incorporating their feed back at least to the extent of if it is functionally meeting the specified requirements which is kind of agile-y.
The main difference between the two at that point seems to come down mostly to the willingness to revisit the requirements which even when my employer was more waterfall we would try to incorporate changes if the customer came back and said what we were doing wasn't going to work at all or they needed changes.
Nope, in waterfall, "deliverables" might mean things like "UI design" (as a slide deck) or "database schemas" (on paper, without data) or "this microservice" (in isolation, and which you cannot run because dependencies and consumers are not implemented yet)
If you are producing anything a customer might actually before the very end of the project, it's not waterfall.
That's what the article is saying in part. Very few people showed or tested absolutely nothing before the very end of the project so if that's a requirement to be 'waterfall' it was a strawman that's easy to argue against.
Indeed. Every real-world practice of development can be placed somewhere on the sliding-scale between Waterfall and Agile.
One of the reasons that waterfall was a reasonable way to proceed was that, in the past, tighter coupling to hardware and longer hardware lead times meant the need to design and specify in advance. This is still somewhat the case where these conditions are true, albeit to a lesser degree.
Having worked waterfall and now agile, I miss waterfall. Agile feels too fast and loose. We work faster but we also redo a lot of things. It's an illusion of progress.
it works the same if you apply it to other disciplines. The saying, "a plan is useless, but planning is invaluable". Agile just skips the second part by trying to throw out the first part.
I think a real criticism of Agile would be that it works great assuming a) domain expertise and b) good understanding of how accurate / precise a solution has to be to work.
Agile seems to work best when the domain itself is technology, rather than, say, when the domain is HVAC control or real-time ECMs.
Oh, I always think the opposite. If the outcome is technical, then quit playing, RTF specs, design and build it. If the outcome is some wobbly user expectation, wobble back with Agile.
there's probably a rational category based on the size/complexity of the data model. I get the sense that very complicated data models are what really ruins the agile approach for complex environments.
What you describe is from micro-managent of the development process. I have never met anyone qualified to micro-manage a software project, and never will.
I too worked on waterfall dev projects. It was a nightmare and did not ship. The Agile Manifesto was a breath of fresh air, just because it captured what a lot of people were thinking in a way that was coherent enough to present to managers as a viable alternative.
On scrum projects I've been on, its essentially the waterfall model. Business comes up with a product and date, product and engineer give high level estimates. Program manager creates a project with all the stakeholders, product managers then write requirements, engineers then write designs. Finally this gets translated into jira epics/stories so engineers can do the implementation. The implementation runs in sprints so engineers can feel like they are doing agile. Finally when its all done, there's manual end to end testing with product and engineering.
> I've been on software development projects (the final product would be source delivered to the customer) where the waterfall model was explicitly specified
On the other hand, in my 50 years or so in this business, working with every size of company, I have never actually seen "waterfall" being done in practice. I'm sure it may have happened -- as you report -- but I don't think it was ever common.
> On the other hand, in my 50 years or so in this business, working with every size of company, I have never actually seen "waterfall" being done in practice. I'm sure it may have happened -- as you report -- but I don't think it was ever common
In my ~20 years of mostly startups and small businesses I have seen waterfall creep in at almost every company. You start by being small-a agile because there is no process. Then something happens – a few big fires ship, or someone misses a requirement, or an exec gets grumpy about feeling a loss of control, or internal users start treating it as just-a-job and want official training for every little thing, or you get engineers who just want to code – and your small-a agile process turns into waterfall.
Ah but we’re a startup, we can’t do waterfall! So you do a series of tiny waterfalls and call them Agile. Everything takes eons of planning, the management class feels super busy, the engineers become disempowered and widget factory like, and all the plans are wrong by the time you implement.
You start getting lots of “we’ll figure out the details then engineers just need to implement, it’ll be easier that way”. It is not easier that way.
This entire discussion or dichotomy is just a massive and sad misdirection. Its explicitly cargo-culting. In what other world do we spend half of our time talking about and conforming to various 'methodologies'. If we just find the right sprint cadence. If we just do retros better. Maybe some kanban-scrum hybrid. If we just _reallly_ limit standups to 15 minutes. If we clap three times at the end instead of two - then perhaps we will be able to deliver software.
There has to be some process, for tracking and communication. We should just have an industry-wide standard that management gets to impose a 5% process tax on hours spent and no more. And we should explicitly recognize that test, design, communication, teaching, engaging with the customer, triage and debugging are how software gets built. There is no magic process bullet. Its a wasteful story invented by management who existentially cannot admit that they have no control over the situation.
> In what other world do we spend half of our time talking about and conforming to various 'methodologies
Remember that this is largely about consultants selling advice to executives. This is not about getting stuff done.
BUT software is also a young industry. We just don’t know yet the right way to do it so we discuss and share what’s worked for us. Just like it took a while to find the right manufacturing processes in other industries.
That's because the "right way" needs to vary depending on what you're building. You don't build a garden shed the same way you build a skyscraper. Likewise, you don't build a twitter client the same way you build an implantable pacemaker.
And for that matter you don’t build a twitter client the same way you built a backend for twitter clients to connect to. In my experience every team and project has a unique way of working and that could be encouraged.
Neither have I. Most of my software career has been spent in medical device development: a tightly regulated industry, and waterfall is just a concept.
Sure, you do requirements elicitation, review and documentation, and then architectural design, followed by detailed design & coding, etc. But it's never a linear process end-to-end. There's always feedback. There's always something you didn't account for showing up and requiring a change to an earlier part of the process.
Waterfall can, and does work, but only on fairly small projects that can be completely defined correctly the first time around. And like everything else, it's easier if you've done that kind of project before.
If you consider this not as a binary choice, but "waterfall" on one end meaning that the whole design process has basically no feedback, and "agile manifesto agile" (not scrum or any other calcification of the process, but the true chaotic "just depend on your engineers to be smart" process), it's probably true there has never been a "true", all-the-way-to-one-end Waterfall design that went for multiple years, because such a thing is essentially impossible.
It is absolutely the case though that many projects were driven with management methodologies way, way too far to the Waterfall side, and that managers would attack developers for essentially failing the process if anybody ever had to incorporate feedback or backtrack or do anything other than 100% rigidly and correctly follow the previous plan.
I don't consider it a "strawman" so much as a "simplification". Nobody could ever truly do waterfall for extended periods of time but there were plenty of people who acted and managed on the idea that the ideal is very, very close to it and to the extent deviations were necessary they are all automatically failures. To the extent that one is trying to discuss management methodologies across an entire industry, if not arguably across multiple industries simultaneously, waterfall is not an unreasonable approximation.
And personally I think in the occasional interminable "oh wouldn't it be wonderful if programmers were real engineers like architects" threads, where people fail to understand those processes used by other engineering disciplines are contingent based on the nature of their work rather than abstract Platonic ideals all should strive for, and those other disciplines would love to work with continuous integration servers and automated testing and strongly-typed components, there are a lot of developers that believe even today that if we just tried hard enough, waterfall could not only work but be the optimal design methodology, and it is we who are failing waterfall rather than the other way around.
> And personally I think in the occasional interminable "oh wouldn't it be wonderful if programmers were real engineers like architects" threads, where people fail to understand those processes used by other engineering disciplines are contingent based on the nature of their work rather than abstract Platonic ideals all should strive for, and those other disciplines would love to work with continuous integration servers and automated testing and strongly-typed components, there are a lot of developers that believe even today that if we just tried hard enough, waterfall could not only work but be the optimal design methodology, and it is we who are failing waterfall rather than the other way around.
You captured so much in this one sentence, especially the end, about how waterfall failed the developer, rather than the developer having failed waterfall.
This script-flip works on many other systematized orthodoxies, I suspect.
It's not really binary or a spectrum. Royce was not taking about what he observed people doing, but how he believed large software projects should be conducted in the future.
In that, he first introduces what has come to be known as Waterfall. While he considered it to be fundamentally sound, he posits that it carries significant risk and then goes on to tell what needs to be added to diminish the risk. Those additions are what oft get called Agile (although not in the Manifesto sense).
You have a point that "simplification" is more in line with the device he was trying to use, but with the intent of leading you into understanding the more complex aspects of his idea. Kind of like that owl drawing meme where you start with two circles and then draw the rest of the owl. There is only one idea present. In other words, "Waterfall" and "Agile" are the exact same thing, just at different stages of communication.
Where others have tried to invent "Waterfall" as it own distinct thing to contrast with "Agile", it would be fair to characterize that as a strawman. If anything all projects are "Agile" at their core, with varying degrees of deviation happening in a multi-dimensional space.
And personally I think in the occasional interminable "oh wouldn't it be wonderful if programmers were real engineers like architects" threads, where people fail to understand those processes used by other engineering disciplines
If the software industry had the equivalent of "general contractors" who pour the concrete, wire the rebar, dig and fill the holes, install the electrical and duct, laid the bricks, all to within the tolerances specified; AND had architects who knew both the tools available and the domain inside and out, a model mirroring the real estate industry MIGHT BE doable. But there are a lot of differences beyond just the "engineering" aspects (and often times, the head engineer on a project is not the architect).
> I don't consider it a "strawman" so much as a "simplification"
I consider it a straw man because, as the agile crowd describes it, there appears to be no such thing as "waterfall". Perhaps that is the result of comical oversimplification rather than a conscious attempt at deception (I believe this is the case), but it still results in standing up a straw man so it can be knocked down.
If a process is 98% waterfall and management blames developers for the 2% and considers it a problem to be solved rather than something to be harnessed, it's close enough to waterfall for all practical purposes. I don't believe there's a sudden transition in the cost/benefits for waterfall at 100%, in either direction. (Just as I don't believe it for Scrum.) The criticisms will apply.
I have certainly seen projects that started by planning everything out. High level designs, milestones, integration dates. Giant GANNT charts. But by the second quarter everyone was pretty much just redrawing the whole map, getting what they could running as early as possible and throwing things off the bus.
Yeah, I think the Waterfall model is what naive non-experts want from a project. I say what I want, you build it, it's delivered on time and on budget, and we're done.
But I think it's basically a fairy tale. "And they lived happily ever after" for executives. And I can prove it. There are basically no successful products that started with an executive idea, were created in a waterfall fashion, and then stayed at that initial version forever. Waterfall is built on the fantasy of managerial omniscience, where the people in charge know everything important on day 1. But the reality is that the beginning of a project is when we know the least. Waterfall in practice is a bet nobody will learn anything as time goes on. And on waterfall projects, that often turns out to be true, if only because course corrections would cause executives to lose face.
I joined a company that had adopted "agile" (in reality scrum + 2 week sprints) after a dramatic waterfall failure. They had attempted to rewrite a good, working, profitable product and had spent 2 years on the designs, only to throw it away because they just couldn't get it completed.
The requirements and design phases can/did often work very well. It's what comes after that derails the process.
When you spend more time trying to update your design to match the implementation (via change requests) than implementing you start to wonder if there's maybe a better way..
2+ decades ago, US Air Force acquisition classes taught exactly this method. I don't recall whether they used the word "waterfall", but they showed the same diagrams and treated software development like massive hardware projects, such as building an F-16: first you write a long requirements document, then generate a voluminous design document, then break the design into a work breakdown structure, farm out component implementation to developers, then finally integrate, test, and ship. It borrowed heavily from the field of Systems Engineering.
In my experience it never worked. We were able to achieve success only by secretly ignoring the rules and process and instead developing software in what detractors called a "cowboy" process. When "agile" came out, it changed our lives. We adopted a few new good ideas, but mostly kept working as we had been. But now we could point to this quasi-official "agile process", with tailoring as they recommend. As long as we were following a process, and not being "cowboys", folks seemed satisfied.
These days the Air Force has caught on to "agile". They even have 400-page manuals on the process to follow to be "agile"! We still cut some corners here and there and do what we think makes sense, but there's far less process push-back than there was in the past.
Acquisitions didn't use Waterfall that I ever saw, until you got to the software specific courses. Then they did, and it was one of several software development lifecycles you were allowed to choose between for projects.
Many program offices and project managers selected it because it was pretty, not because it was sensible.
> These days the Air Force has caught on to "agile". They even have 400-page manuals on the process to follow to be "agile"! We still cut some corners here and there and do what we think makes sense, but there's far less process push-back than there was in the past.
Circa 2010 (+/- a couple years) USAF also picked up Lean in a big way. But their version of Lean was almost exactly the opposite, in practice, of what was done and described by industry as Lean. A key element of Lean being that you actually let the people doing the work provide feedback and direct improvement efforts. USAF's version had the managers (who never did the work) walk around and observe, then change processes to be "leaner". That is, pure scientific management in the Taylorism style.
USAF is a great place for good ideas to get their names reused for old ideas.
Here’s a 2019 presentation about Lockheed Martin’s F-16 team adopting SAFe (Scaled Agile Framework). It was a successful first step because the dev team was able to deliver Program Increments to QA in just nine months, down from 3-4 years.
I'd argue that designing an aircraft still fails badly with waterfall and it is a major reason that aviation is massively behind where it should be right now. Space-x shows that you can build rockets, a lot better, if you ditch that waterfall process.
Agreed, waterfall fails right off the bat at "gather requirements."
If you ask the Air Force how fast a new proposed plane has to fly, they'll say "as fast as possible." Or maybe they'll say "fast enough to accomplish the mission and win wars." But neither of those would be accepted as requirements.
So in reality the Air Force will answer that question with another question: "well how fast can you make it fly?" Which of course depends on a lot of tradeoffs of performance, munitions, and cost. So in reality lots of design and technology tradeoffs go back and forth during the requirements phase, and at some point someone makes a rather arbitrary requirement like "The plane must be able to fly at Mach 2.5." That gets set in stone and drives the program forever after.
So the very notion of "requirements" is complete fiction. Perhaps the plane could have a top speed of Mach 2.2 and still achieve the mission, or go Mach 2.8 and fail to achieve the mission, depending on other aspects of the design.
I worked at a place where, while it was never called "waterfall", it was absolutely the way things worked. I think it naturally evolves this way:
1) a software project, when finished, turns out not to fulfill all of the things people wanted
2) "we should plan more carefully next time, so that all the requirements are identified at the beginning"
3) the next software project starts to resemble waterfall, but still misses some requirements
4) "we should spend more time on the requirements phase next time, so we don't miss anything"
5) etc.
It is the natural method that large organizations end up with, in the absence of any philosophy saying otherwise. It's not the natural method that startups or small organizations end up with, probably, because it involves a ton of meetings first, before anything is done, and that is something that happens more in large organizations.
Waterfall is what you get when it is always the safer option to say, "wait, let's spend more time planning out and getting buy-in". There may not be many places that call it "waterfall", but there are a lot of places that do it. Some of them even call it "agile".
The way you can tell you're in one of these dysfunctional companies in my experiences is at the moment you, as a software developer, have to attend TWO meetings in one day. Companies that have too many meetings tend to have middle managers with only one goal for all these meetings: "Covering their ass." They treat these meetings as a way to collect evidence to be used later to prove that they weren't at fault when the project fails to meet it's objectives.
I'd say more than 5 meetings a week for an IC rather than two in a day. (I have 3 meetings a week, but two of them are coincidentally on the same day). Managers will naturally have more meetings.
I agree, you're right. I didn't think of it that way because most agile teams have a mandatory scrum meeting in the morning every day anyway. So a meeting is always literally the first thing you do...or at least it's your first interruption that comes right about the time you begin concentrating.
It's super counter-productive too because in the morning is when I'm at my most productive and a guaranteed interruption every single morning is horrible.
> It's super counter-productive too because in the morning is when I'm at my most productive and a guaranteed interruption every single morning is horrible.
At least in my bubble, tech seems to be skewed heavily towards night-owls. I winder if putting the meeting in the morning is due to people assuming that, since they aren't productive in the mornings, neither is anybody else.
In my 20s and 30s I wasn't productive in the morning mainly because chances are I was out half the night drinking. Since hitting my 40s, I'm most productive in the morning, because I'm never out late.
When people talk about Waterfall Model they forget the context of the era it originated. I've worked on a waterfall project early in my career. Please keep in mind that back in the 90s most software companies didn't have CI/CD, there was no cloud, releases were hand-delivered to the customer and usually rolled out about every 6 months because technically agile wasn't possible yet for most software shops. Waterfall was a valid method back then due to the technical (and cultural) limitations.
Haven't lived back then I'm not sure today's CD is better. Too often web breaks features people rely on. Worse they just do it randomly with no notice and no ability to have a transition time while you update. I miss the stability of knowing things will work like they did for a long time and when they break it is at a time I choose to apply the upgrade. (it didn't always work out this way, random bugs were a thing and still are)
Quality control was also a lot more important - you couldn't ship something with many bugs as customers would be forced to look at competitors if they hit your bug.
Meanwhile, the Royce paper that takes down the simplistic series of steps arranged in a waterfall, is a sort of formalization of an approach better visualized in late 80s as "the spiral model":
The concept of both, well before the 90s, is you don't know what you don't know, so its faster and more successful and costs less to make, learn, and document from prototypes before you know, to establish what you're really making.
I feel like this post has some nuance or clever wordplay that I'm missing. So if that's the case, apologies for adding noise.
But in the real world, the waterfall model was absolutely not a "strawman", but instead was literally how almost all software was built, up to even the turn of the century and beyond. Software projects were smaller in general, compiling was a major undertaken, you collaborated on projects by sending files around or, best case, working on a shared network directory. The pace of change of tooling and "libraries" was much slower and more predictable.
As we got source control, intellisense, massive knowledge bases, and then the rapid iteration of code sharing in the form of libraries and so on, things started changing because the model was too slow. But it was absolutely real and the norm.
Not exactly. From first principles, it could only possibly work if the project was very well-known/trodden ground already. So of course mistakes were either fixed when discovered or the project failed.
(Yes, some govt projects pretended to follow a strict process. What’s new?)
But even Brooks’ original MMM (1975) encouraged iteration as a way to validate assumptions.
By the second time, you actually have a reasonable chance of knowing what the requirements should have been the first time. They might even be valid for the rewrite, if things aren't moving too fast.
That's how I did waterfall. We would go through all the requirements, group things that were related, and assign them to a developer who owned them. Repeat until there are no more unsatisfied requirements.
I dive into this in my blog, "What is your alternative to Agile?" - https://www.ebiester.com/agile/2023/04/22/what-agile-alterna... - but the Structured Systems Analysis and Design Method as well as PRINCE2 were common in the industry, but both were examples of methodologies that took waterfall and codified it. However, the last waterfall project I was on was in 2013. We had formal gates out of each section of the process. (Even there, we tried to make it as incremental as possible, but it was a Fortune 500 company that had an overarching process.)
You also have to remember that there are a lot of software projects that do have a "done" state, after which the project goes into maintenance until there is more funding for improvements. Consider an internal project to turn a department excel sheet into an application. You can quickly reverse engineer the current behavior, go to the stakeholders and get a set of the desired behaviors above and beyond what the spreadsheet does, negotiate a scope, write a small design document, and just go do it. You then demo it at the end and change what is necessary before they start using it. You have a small set of bug fixes and QOL improvements that follow, then the project is handed off to a team managing 500 similar projects overseas and is responsible for security and bug fixes.
This doesn't make sense in product companies for good reason. However, on small projects, waterfall can work.
The Royce paper is actually still worth reading. It's well written and if you can step over the 50+ years of history since then also still somewhat informative. And of course the word waterfall doesn't actually appear in it. That word was slapped on it by others afterwards. And of course Royce vaguely suggests that going through the steps more than once might be helpful. What we now call iterating.
The key concept for what we now call agile (which mostly boils down to variations of scrum these days) actually has roots dating back about half a century. People were suggestion spiral development at some point (converging on some final thing) as early as the eighties. There was the whole 4+1 model which got caught up in the whole UML movement and it's associated process.
The key innovation that extreme programming (one of original agile methodologies) brought was that increasing the iteration frequency and giving up on the notion that you can do a lot of requirements and design up front. Things change. Every iteration. So having a lot of requirements and design documentation to update every cycle is counter productive. Dropping that was considered extreme. But then people realized that that worked just fine and that these designs were kind of low value artifacts to begin with. Not really worth the hassle.
With Spiral, the iterations explicitly involve the customer. This is important.
With Waterfall, there is an upfront spec, but implementing the whole thing without consultation with the customer can be a bad experience.
With Agile, maybe there's a lot of internal correction. But the key thing is to involve the customer in integration testing. Unless both sides are very experienced, surprises due to miscommunication are the rule.
It's mainly iteration length that has shortened. Royce was saying do it twice (including requirements engineering, which presumably would involve some kind of feedback). Spiral development increased that to doing it multiple times. Rational unified suggested a quarterly pace. Most agile methodologies work with sprints of a few weeks.
And lately, continuous deployment and Kanban like methods remove iterations completely and release continuously. Ship when ready and develop asynchronously. You can still have planning cycles with this of course but they are decoupled from release cycles.
The Linux kernel is a good example where you either make the merge window or wait for the next one. Large companies like Meta are also know to work with scheduled releases that are independent from planning cycles (e.g. weekly) of teams.
All project management is terrible when you are following it blindly and have no understanding of what it takes to succeed.
Waterfall works when it's done right in the right environment. It's a nightmare when it's not. Agile works when it's done right in the right environment. It's a nightmare when it's not.
Having a good project manager who understands what it takes to succeed from a management/executive perspective and who understands how to keep engineers both productive and happy is priceless.
During the waterfall days, you would run into managers who would gannt everything and harass people into meeting deadlines for whatever would solve the 8 word description of the item on the chart. These days, you run into managers who are happy to distribute a jira ticket to resolve anyones gripe.
And then there are the thoughtful ones who understand priorities, factors for success, and how to set reasonable expectations on both sides of the table (for the techies and non-techies)
In the end, it's not the process you follow, it's the results that matter.
> In the end, it's not the process you follow, it's the results that matter.
I was nodding along with this post up until this last sentence.
Yes, the results are what matter, but process is what drives the results. It is thus critical to the success of a project to ensure that the process is appropriate.
For example, the entire purpose of agile is to have short iteration cycles where you deliver to customers and get feedback before starting the next cycle. If you have a product where you cannot get feedback, agile is a bad solution! You will deliver every two weeks - and then continue to do what you would have done anyway. That makes all the agile ceremonies quite the waste of time.
Conversely, if you ARE getting feedback regularly it's insane to do waterfall when you're two weeks into a 6 month project, and the customer doesn't like what you're showing them.
This can get a lot more detailed at the micro-level for managing process on teams - there are tradeoffs between developer happiness, speed, quality, visibility, and many other axes that process can adjust, and a team that is set up with good process will be set up to execute better than one that isn't.
I tend to be someone that is perceived to "hate process", but I don't, I hate bad process that is counterproductive to execution and achieving results.
Royce's paper is one of the best pieces on how to manage software projects that I've ever read. It's quite short, but every time I re-read it I notice a new insight I hadn't noticed previously.
Royce did not present that waterfall diagram as a straw man. The structure of the paper is itself rather agile: he starts with the simplest thing that could possibly work, identifies problems with it, and then progressively iterates on it.
That certain people in the Agile community continue to perpetuate the myth that this model is a serious thing that people actually thought was a good idea might be a straw man. But ignoring the rest of the paper is probably good strategy. That one page is a useful starting model for them, too. But they really woudln't want to call attention to any other page of the paper. The rest of the pages are too full of hard-won observations that speak to why Scrum seems to work out so poorly in practice for large, multi-team projects.
Reading this thread is bumming me out because it's made me realized my company USED TO have a good fusion between 'waterfall' and 'agile'. The requirements development phase, development, and testing phases were all very flexible and had feedback mechanisms as we gradually figured out The Right Way to get the thing to work.
Systems, software, and testing all worked in close concert so that software developers could find problems or gaps in requirements, as could testers. And of course there was a strong feedback loop between software & test. Meetings were weekly and people reached out to each other as needed outside of that. A daily standup was usually a sign that something was wrong.
In recent years we've moved to cargo-cult capital-A Agile, so we've basically traded our flexible process for a LOT more meeting overhead and pretty much a negative gain in efficiency. We spend significant portions of meetings talking about process which was never a problem in the past.
All because we didn't fit some predefined one-size-fits-all framework... sad!
(and of course the REALLY dumb thing, is that we're still often tied to a delivery schedule of 1 or 2 builds a year, with customer selloff testing - so the external process we fit into is still 'waterfall-y')
e; I guess one thing I neglected to mention here is schedule. We usually never had issues with schedule, our timelines were generous enough that even if we underestimated the complexity of something we could still make the delivery date. (admittedly there would sometimes be crunch periods in the last few weeks before delivery)
The author is fortunate to have so few encounters with this IRL because there is a world of difference between “I have never seen a book propose this” and encountering it in practice.
To my misfortune I have been involved in multiple ERP implementations where such require heavy customization & development of custom & bolt-on modules.
This model wasn’t explicitly presented in this visual style but it was the approach. Requirements were set nearly in stone even as business needs changed during a multi-year project. The result was systems people avoided using, creating shadow systems or surprising IT with “we bought this and need it integrated”.
I personally can't comprehend building software with the waterfall method. I always do a reverse waterfall: build the fundamentals at the bottom. They are the non-negotiable "truths" of the problem, representing something close to the minimal complexity. Then, tie them together to work towards the relatively mushy end goal, with the abstractions being much more obvious as you work your way up, with a few "shifts" where higher level abstractions may pop out and collapse things into simpler pieces as you go up.
I would consider the GUI being one of those "truths".
The Waterfall Model had its time and piece of the pie (still has in the form of modified Waterfall models) at the beginning of the software development era when software was complex in nature. Therefore, time spent early reduces costs at later stages e.g., a problem found in early stages is cheaper to fix than later in the process because the software has to be embedded in the hardware - no software updates.
We all know that it's not easy to find a good software engineer back then, or a knowledge center (like we do now) to get help from. If one team member leaves in the middle of an ongoing project for whatever reason, good documentation must be there for the new member to get a complete understanding of what's going on.
The Waterfall Model was never perfect, and Royce never claims it is. Instead, he himself pointed out major flaws such as testing only happened at the end of the process.
One thing I want to add is that Royce didn't use the term Waterfall but he said something like downstream. And he was right because we all know that speed of water is very fast but in this model it's too slow. Perhaps that's why he proposed modified versions of the original Water fall model https://www.researchgate.net/figure/Royces-modifications-of-...
I don't think this post is quite accurate that Royce proposed the model just to critique it. Royce's 1970 paper describes a way of adapting normal project management practice to software.
Royce's criticism of the model touches on the brittle nature of specs in the face of discoveries about performance that mean a project could potentially have to start over.
Agile, however, has a lot more solid basis in the difficulty of estimating software development tasks. Using traditional project management tools, you would do a resource-leveled critical path analysis, which is a very heavyweight way of optimizing who does what and when, which then within a couple weeks is no longer useful because your task estimates suck. Instead you get. the team together every couple of weeks and decide who does what. Rinse and repeat.
Agile works better because estimates almost always suck but that's OK because that doesn't break your exquisiite schedule analysis because you're not making one.
Yep and here we are in 2024 and just this last week I got into a heated discussion with an 'Technical' Program Manager raging about how the deliverables are slipping by three days mostly because he and his up chain are heavily invested in a schedule that is built on hope. Not only are the estimates bad, but the resourcing from the different silos has not happened either, so there is tons of unfinished work just on the work that is known, let alone the unknown unknowns!
Next up he's about to find out his integration timeline is complete and utter bullshit.
Time to get a new TPM. Any TPM worth their salt should be doing everything in their power to catalog and mitigate those risks, and communicate them upwards. Lack of communication in both directions and adversarial conversations with engineers is a whole parade of red flags.
That said, Gantt charts absolutely have their place alongside Agile. Our budget and goals are set yearly so inevitably there’s going to be milestones and work back dates to meet, as well as cross-team/org dependencies to track.
I wish that discussions of Waterfall, "Agile," etc, and systems/software development methodologies would spend more time considering the motivations and rational reasons for why the process approach was created. The practice of systems and software engineering has existed longer than many of us have been professionals, and in many cases longer than many of us have been alive.
The "Waterfall" systems (or software) development model was developed to reduce the likelihood and impact of requirements or specification changes over its development lifecycle. Likelihood and impact are elements of "risk," and the process can be seen as part of risk management. Rephrased, the Waterfall development methodology as a process was intended to help ensure that the system being developed (and delivered) was the correct solution (i.e. "valid") for the problems considered, and that the process of getting there would have the best known and acceptable costs.
With any instance of a development process, there are risks of: Not getting the requirements or specifications correct (i.e. Failing to understand or solve the actual problem), Completion delays due to time spent on re-design or re-implementation from revisions to requirements or specifications, Completion cost overruns (i.e. delays) due to re-design or re-implementation, etc.
The Waterfall process approach was eventually codified into things like MIL-STD-498 (https://en.wikipedia.org/wiki/MIL-STD-498) for software development. Waterfall is not specific to software development, and some lessons ingrained in the process came from disciplines where the cost of misunderstood requirements, changing requirements, or incorrect specifications are higher. Examples could include the design of a bridge, building, space launch vehicle, network communications systems, etc. In these cases, the further you go into development, the more costly ambiguity and/or errors in understanding the problem become.
Unfortunately, as seen with many "processes," strict adherence to process or ritual without understanding or sanity checking what is being practiced against the rationale or purpose for those processes leads to poor outcomes. This is what the authors of the Agile Manifesto were responding to, and ironically the negative pattern of adherence to process without understanding why has replicated itself with modern practice of "agile" -- That is a human behavior and organizational culture problem.
It doesn't matter what you call your process, you are setting yourself up for failure if you don't (1) clearly understand the problem you are trying to solve (2) think holistically about your solution (and its risks) before you start building it. This is true whether you are making a small bug fix or enhancement, building a new system from scratch, or anything in between.
Processes are tools for doing these things, but they can also sometimes obscure when they are being done poorly and in some cases don't allow them to be done well—there are some places where you have to go deep on understanding the problem or deep on validating the solution and the process works against it.
The bottom line is that (for many cases) you want to take advantage of the mutability of software while not just winging everything on the fly. There's probably a reasonable medium which will differ depending upon the use case.
Just because there was research from 1970 (as there was in subsequent years) showing that big design up front is a bad idea doesn’t mean that waterfall is a straw man argument. It is probably necessary when you are shipping code with extremely high costs of operation, where mistakes are extremely expensive (i.e. missiles, space shuttles). I imagine automotive ECU software is probably in that category.
The software industry has ignored research from 1970s and on and continues to ignore it today.
Look at the microservices craze. It’s another way that big-design up-front has been brought back.
When I was studying in the late 80s / early 90s, the text books contrasted the "old" waterfall approach with the more "modern" iterative approach. That was long before Agile or whatever had been invented and recognised that there needed to be a feedback loop.
Trying to promote agile/scrum/xp/whatever by attacking waterfall is a straw man argument in my view because it is not comparing against what came before. That's not to say that clueless managers don't still like to reinvent and impose what is essentially waterfall.
Yeah this kind of thing definitely happened all the time at big corporations 30+ years ago as well and it comes from traditional engineering projects where changes later on in the process are very very expensive.
Hate me for it but iterated waterfall was the best time of my life and I still think it’s far superior to agile.
My first job, we actually took time to think about the system design. Being forced to get proper quality insurance manager approval before moving to build meant you couldn’t cut corners and having a proper testing team running a full qualification on what was produced meant things were always tested in depth from the point of view of a user before release.
Every parts of the system were properly documented and we had proper tooling allowing us to go from system design to component design all the way to a specific version test results which was incredibly nice when trying to understand what was happening.
Everyone was working on multiple components being in different phase at the same time so there was no downtime and you would just restart design of a new version as soon as you got back feedbacks from qualification.
I have probably never been as productive in my life and everything was working like a well oiled machine. Every agile project I have ever worked on is a complete mess.
It was not a straw man. I've seen it specified in contracts. I've seen audit teams sent in to verify an SDLC (system development life cycle). Arthur Andersen (now Andersen consulting) had it formalized in their "Method 1" system development approach.
Any semblance of agile was met with hostility. You were labeled a "cowboy programmer" or "hobbyist programmer" if you dared start with code instead of specification and approved plan.
Also, it is easy to forget those "rules" weren't wrong. People were coding in non-agile languages. Version control tools had strict checkout and locking. Project communication was in the form of rows of three ring binders -- everytime you added or changed a function, you marked up the existing doc page and a secretary retyped it with carbon paper (for a subject book, title book, and subsystem book).
Changed to requirements were very expensive, so the whole system was designed to get full buy in a once. Consider that even now in this "age of enlightenment", we take a waterfall approach in nonsoftware projects simply because changes are expensive. If you're having a custom home built, you need to make a lot of decisions early. You're charged heavily if you want to change the spec during construction.
To me, much of what has been said about Waterfall is a strawman. Firstly, the idea that no-one ever iterated doing Waterfall is just not true. The idea that Gantt charts are some sign of evil is, IMO, misplaced. Like all tools, they can be used poorly - but so long as you keep them regularly updated, they can be quite powerful.
In a prior job, another dev - a lovely guy - claimed that Waterfall projects always failed, which was news to me as I'd worked on dozens of them and none had failed.
I feel like the take home message is perhaps that we tend to mythologize processes and make them into caricatures of reality. The actual truth is always more complex and more nuanced. Which, ironically, I think is kinda the point of the Agile Manifesto. At any rate, I certainly feel that most people I've ever met who think that "doing scrum" is Agile are less agile than the people I used to work with doing Waterfall. It's not about processes, its about people and interactions.
The irony is that the proposition that "someone wrote a book that proposed waterfall as the best software method" is itself a strawman argument.
To my knowledge, that has never been claimed.
Waterfall is what many of us old fogies in the industry experienced as the "defacto" methodology for a long time. It made intuitive sense that in order to design a build a project that you would first, you know, DESIGN it. Then you'd kick over that design to software developers that were expected to implement it.
Iteration in the design and development process, the idea of "people before process" and getting designers and engineers to collaborate early on etc. was not obvious. That's where all of Agile's "waterfall" talk came from. The fact that for a long time what companies were doing, while never exactly the same process as each other, was always waterfall-like because that's what made the most sense in an industry that was very new and in which no one knew wtf they were doing... so they took knowledge from other domains and tried to make it fit. That's a large part of what Fred Brook's The Mythical Man Month talks about.
It's only now that a new generation of developers has come up in a world where all they've ever known was "Agile" and "Scrum", that the world they know is so far removed from the "non-Agile" world that these books describe.
A colleague of mine the other day was talking about experimenting with something using the browser's `postMessage` API 8 years ago. My initial reaction was "did postMessage exist 8 years ago?" And then I remembered that 8 years ago was 2016 and it's already 2024. Many "experienced" people coding today have 5 years experience... and then they talk about concepts that were a reaction to how things were being done in the 80s and 90s as if those decades never happened ... because if they had even been born yet they were still children, so they weren't there to live that reality and the pain that what came later was a reaction to.
Which, given that that's a military spec, also speaks to a motivation for such a tightly controlled approach: the cost of design changes is truly immense. When you have a large government project with MANY different contractors working on different pieces of the system, a lot of Agile principles need to go out the window. The spec needs to be fairly well nailed down up front because a late change that affects adjacent systems gets really expensive when those adjacent systems are being managed by a completely different company. That requirements tweak may now be a full on contract renegotiation. And, as Boeing's recent woes illustrate, communication among all the subcontractors may be so poor that even identifying the potential impact of a specification change may be difficult to do reliably.
Not such a big deal in a lot of tech projects where it's relatively inexpensive to solve problems as you find them. But Mars rovers don't get to have canary deployments.
Also, even then, it's still not really "textbook" waterfall.
"Waterfall" is just a pejorative term used against the kind of project management that uses a Gantt chart, which kinda looks like a waterfall. This kind of project planning is necessary when you've got engineering steps that are time sensitive and take months to years. Like if you're building a large bridge you need to schedule the resources to do individual steps a long time in advance.
Writing software was initially run like this and there was a big pushback because most of those old school engineering methodologies just aren't justified because when you're writing software all of the steps look pretty similar and the design/build/test cycle can go through a full cycle in minutes instead of years and you get to do it millions of times instead of, like for a bridge, only once.
Those engineering practices are still necessary when you're building things, sometimes a bit less so with electronics hardware these days we have prototyping that can turn around very quickly, but still if you're doing a large physical engineering project, you do lots of "waterfall" because that's the best tool for the job because the job requires it.
> designers and engineers to collaborate early on etc.
The really scary thing to me is that I'm old enough to remember when all the trade rags were excitedly talking about how it's a great idea to not just "throw your design over the wall" but work with the software guys to understand what their needs were and accommodate them.
The scarier thing is that they were talking about this in the year 2000.
Yes, the person that invented that name did personally say he created it as a strawman and never saw it applied anywhere.
At the same time, the waterfall model was the standard model for contracting software in large organizations until around the 10s (yep, 2010s), usually mandated by all kinds of compliance rules.
Almost twenty years ago I worked on a project where an external unnamed “big four consultancy” had written a very long document titled “statement of works” that had about 130 pages.
It described a LOB application for a corporate customer in minute detail. Every form was described with the order of input elements, fonts and font sizes to be used, grouping of fields, you name it, it was there.
We just followed the instructions exactly and after 15 months we delivered the finished application.
These kinds of projects did exist but the specification and requirements phase was long and expensive.
However it required the client to take the time to understand their current business processes and more importantly what they should be and how they wanted them to work.
It was one of the most mundanely boring projects I ever worked on.
I have never seen waterfall in pure form. Mostly some kind of big upfront requirements projects with implementations iterations and a lot of project change management during the dev phase. These upfront requirements periods could be anything from a couple of weeks to a couple of years. While, I don't doubt that long requirements phases can have some value in aligning stakeholders on a new direction, they often became a raison d'être for complete teams - often stopping other promising projects in its wake: "You have to align with project jabberwocky before we can sign off your project." Agile seemed like a way to start early and get reduce the inherent waste by building software on paper upfront.
The waterfall method is EVERYWHERE, entrenched, systematic, and pervasive. Even when you're supposedly doing Agile, there's always half the team still thinking in waterfall.
In any non-digitally-native company, including many F500s, waterfall still happens, is still happening, has always been happening, will likely continue to happen.
And you know what? That's okay. Choose the tools that fit the job, not fit the job to the tool.
Why do you think it's more prevalent in non-digitally-native companies? I've often wondered if it's because those companies are uncomfortable with software development in the first place, so it makes them feel better to have a finish date for the project.
But also, if you're making hardware for example, you can't just go back and 'update' the molds, the assembly line, change the material composition, etc. The lead times are insane, the changes are expensive, and the downstream consequences can be disastrous. This applies to everything from medicine, to farming, to government.
My first job in development was at a lending division at a bank. After that, I was at a large health insurance company. (1999-2005) Waterfall certainly did exist and it got even worse at the health insurance company. My official title was "Application Developer" but I spent about 60% of my time filling out reams of paper that got passed around in meetings with everyone under the sun that took another 20% of my time.
The first time a startup recruited me and described how they worked, I jumped on that mainly because I'd actually be coding.
Gated development cycles were/are common, regardless of what you call them. If the target is not moving too fast, the process can work. If computer time is vastly more expensive than programmer time, working 'offline' writing/checking specs is time well-spent. If you take the standard SDLC steps, apply them to the smallest useful piece of functionality, replace written specs with automated tests, you get a single-piece flow model which strongly resembles agile practices (but says nothing about agile philosophy).
I love realizing that I'm old enough that people think that practices that were the norm at the start of my career don't seem credible even a decade ago.
Plenty of people have written books that confirm/deny the efficacy of the Waterfall model.
But in the meantime, there are far, far many more folks - by significant orders of magnitude - who have written software with the Waterfall model.
Far, far more.
The fact that it is still with us, and can still be used quite effectively sort of leads credence to the idea that those who can, do, while those who can't, teach (or write books about it).
It's funny because I had to take a company mandated 2 day Agile training class, and I thought the exact same thing. I thought "Waterfall" was just some concocted fantasy workflow to contrast with. I actually asked our instructor if it was real and he said "Of course it was!"
Waterfall was named as a strawman. However it is very similar to what a lot of projects do. No project does waterfall as described because there are always things that can't work that way. (some projects get closer to waterfall than others)
Enlighten me - what is the difference between a functioning ( milestones, sufficient interaction with end user, frequent monitoring of scope creep, iterative etc.) waterfall and agile?
I see no difference. I have read the agile manifesto in the distance post and nothing seems to stand out.
Waterfall is a straw man, early descriptions by Royce were written specifically to criticize it. Waterfall is mentioned in relation to agile to sing agiles praises. No serious developer will claim to use waterfall.
There are however, a suite of scientific management approaches based on the work of Henry Gantt which have been used, and are used today, that fit under the umbrella of waterfall approaches, such as the program evaluation and review technique, critical path, critical chain, and earned value. These are still in use today, and in fact government contractors are legally required to use earned value for acquisition programs over a certain value.
Whaaaat? Even 10-12 years ago Ive worked for companies that used waterfall. Most hardware/embedded companies do, because it works for hardware. The problem arises when they try to use it for software too (though embedded companies have gotten better last 5-7 years)
- author agrees that there are people that actually use it as a methodology for their software projects
- But because no one wrote a book about it, author assumes talking about "the waterfall model" a strawman.
To me, this sounds like moving the goalposts. One comment fits my experience :
> The Waterfall model IMHO comes from Taylorism. Is a serial assembly line that follows an strict division of labor, management that thinks and workers that execute, etc. Having worked with professionals beyond sw development, they don't call it "Waterfall" but it is everywhere.
My most successful project management experience ever worked like this: we had a massive Gantt chart showing all of the work we had planned. I added and removed rows daily, updated expected completion dates, and generally rearranged the whole thing. The one thing that never changed was anticipated delivery date. Every week I sent the CTO a report with a snapshot and an explanation of what changed and why. I expected to get yelled at more than once, but he was happy with the sense of control, and the developers enjoyed the flexibility.
It was exhausting and I’m glad I’m not doing project management in my current role.
Yeah this is strange how every agile coach has a sales script that begins with extolling the evils of waterfall.
It's far more likely that the customer/boss adds features and requirements way late in the process. As an anecdote, I was working on a small mobile app, and two days before release date, my boss came in and demanded that I make the app work on ancient iPhone's with tiny screens, which involved having to redesign large parts of the UI to reflow in ways I hadn't thought of. He justified this by being 'agile' and 'forward thinking'
Waterfall might have been a straw man but SADT and other structured design principles put an unbelievable amount of dependency on diagrammatic and black box formalised boundaries of flow. All done up front.
People mocked things and prototyped things but I sat beside people who worked for 2 years or more on wall sized collections of ring binders of requirements specifications and flow charts, to end in acrimonious lawsuits.
I do kind of hate agile language. It's smug. But I love rapid prototypes and sprints.
OTOH, I've been in that situation too, and it was successful. The International Space Station has not yet fallen out of the sky. There are situations where waterfall is appropriate.
I am curious if this is usually argued. I thought it that was generally held that agile and similar methodologies at least in the sense that sprints are defined in days/weeks and not months/years is for use cases where the product doesn't have well defined specifications.
And yet the ISS has still had many bits added on, replaced, upgraded and modified. They just work to far, far higher standards than almost any company will pay for because they know if it goes wrong some very high profile people get dead.
In my field (troubleshooting for enterprises), I encounter, literally every day, prototypes (rapidly thrown together things that 'work-ish') in production and spewing bugs. I wonder where these companies are that actually toss the prototype and do it proper afterwards. Never seen it live, only on paper.
I've done many, many Proofs of Concept that were thrown out after exploration to make way for properly written production code. It's part of any new greenfield project I work at, we do a rapid prototype to validate some early design, learn from it and throw it out.
My field is not enterprises though, I worked all of my 20+ years career at tech companies of different sizes (from startups to 10k+ people orgs), startups and smaller companies usually will throw a PoC into production, and call it "tech debt" for later, larger orgs tend to avoid that since they've been previously burnt by the maintenance burden of poorly designed code in production (usually on their startup-ish phase).
1. You're a contracting house, your clients are hopeless, and you just want to start billing hours, and keep billing hours every 1-2 uninterrupted weeks of peace. Clients saying something different every 1-2 weeks is no significant harm done, since you don't have to care, you just want to keep billing hours.
2. Possibly in-house rather than contracting, stakeholders and developers collectively have little idea what they're doing, whether in the problem/system domain or in process, so planning is mostly pretend and counterproductive, and best minimized. Just do something now, and everyone will quickly see whether it looks in the right direction. And where this model breaks down, you can duct tape it with firefighting meetings that have some people looking like heroic decisive leaders with a bias for action (win).
That's fine, but these people should quietly enjoy their Agile, keep their heads down, and stop trying to evangelize Agile to people who don't have (or are getting rid of) either of the above two dynamics. Also, if they find themself saying "Waterfall", that's probably a reminder that they've accidentally started evangelizing, and in a parroting way.
> these people should quietly enjoy their Agile, keep their heads down, and stop trying to evangelize Agile to people who don't have (or are getting rid of) either of the above two dynamics.
I disagree. I've seen more than my fair share of people signing on "big" IT contracts that promise nothing except specifications before Y+2 or Y+3, and these people need to see the light. To date, I have never seen any multi-year software project that doesn't start delivering early land softly. And whenever they crash, it's the teams that suffer.
OK, they should limit themselves to evangelizing to dynamics #1 and #2. Something like:
1. "You people only care about billing hours, and Agile is how you do it nicely."
2. "This/these organizations are systemically incapable of coordinating effectively on something like this, so Agile is probably your best bet for eventually reaching a passable solution, and reassuring people in the meantime."
3. Hot shot VP in non-software company starts a small in-house software team that immediately has to manage multiple small/intermittent software projects where the product owners are half not paying attention / half don't care, and the team just wants them in the room at least once or twice a week.
This drama has played out in almost every company over a certain size in America I'm sure
I think what you're trying to say is that there is no one development process that fits every situation because all situations are different and thus what you need to do to have a successful software project is adapt the process to the business and do what works.
The evolution of software development methodologies, from waterfall to agile and beyond, reflects broader shifts in business models and power dynamics within the tech industry. As companies have moved from traditional profit-driven models to ones focused on stock value and rapid growth, development practices have adapted to prioritize speed and flexibility over long-term stability. This shift has coincided with a change in the role and autonomy of engineers, who once had more control over the development process but now often find themselves navigating business pressures and shortened cycles. The debate over methodologies like waterfall versus agile is thus not merely about technical approaches, but about fundamental changes in how value is created, how engineering talent is utilized, and how software projects are controlled and prioritized. This context helps explain the generational divide in perspectives on these issues, with older engineers potentially valuing stable, well-engineered systems, while younger developers may be more accepting of rapid iteration and business-driven development cycles.
The problem of Waterfall didn’t arise in the initial paper. It arose in subsequent interpretations. Particularly, see Parnas’ classic paper arguing that we should pretend to follow the “right” practices [which he defined as essentially Waterfall] even if we didn’t.
I call this Parnism. It’s Parnism we should fight, not Waterfall as such.
I've been on software development projects (the final product would be source delivered to the customer) where the waterfall model was explicitly specified, with the whole design- and implementation phase based on this, with milestones where each step of the waterfall would be delivered and checked by the customer. This was particularly prevalent back in the eighties and beginning of the nineties. It's as real as can be, it did exist. Obviously developers couldn't follow that 100%, so there would be some amount of back-designing an earlier stage, but if it wasn't 100% it was very close in practice too.