History of Software-Industrialization Waves

History of Software-Industrialization Waves

Every generation has tried to industrialize software production and eliminate, or at least deskill, the programmer. Each wave under-delivered, and it under-delivered for the same reason every time. The waves rhyme because they all made the same category error: they treated software's hard part as typing (accidental complexity) when the hard part is understanding the problem (essential complexity). That is the strongest historical case that AI-scale codegen, which again collapses the cost of expression, relocates the constraint rather than removing it.

The intellectual anchor: Brooks, "No Silver Bullet" (1986)

Fred Brooks split software difficulty into essential complexity (inherent to the problem domain) and accidental complexity (from our tools and notations). His claim: no single tool or technique will deliver a tenfold improvement in a decade, because tools only attack accidental complexity, and the essential part is what dominates. Shrinking accidental effort to zero does not touch the essence. It is the lens for reading every wave below.

• No Silver Bullet, Essence and Accident in Software Engineering (Brooks, 1986, PDF)
• No Silver Bullet (Wikipedia)

CASE tools (late 1980s to mid 1990s)

The promise: model the whole system in diagrams and specs, let the tool generate complete working applications, and make software engineers largely obsolete. At the peak, dozens of vendors were selling well over a hundred competing CASE tools.

Why it stalled: the U.S. Government Accountability Office reported in 1993 that "little evidence yet exists that CASE tools can improve software quality or productivity." Tools mapped poorly to real platforms, did not scale to large projects, and left the garbage-in, garbage-out problem untouched. A conceptual gap sat between the engineers who built CASE tools and the ones expected to use them.

• What is CASE? (TechTarget)
• Computer-aided software engineering (Wikipedia)

Fourth-generation languages and visual/RAD tools (1990s to 2000s)

The promise: replace typing code with visual interfaces and higher-level declarations. Fourth-generation languages were the first big attempt to eliminate code from coding, and early-2000s tools were heralded as the future.

Why it stalled: they shone on simple applications and fell short on complex ones. They equated programming syntax with the real challenge, which is problem-solving and application design. As requirements grew, the abstraction leaked.

• Broken Promises of the Low-Code Approach (The New Stack) traces the lineage from COBOL through 4GL to low-code.

Offshore "code factories" (1990s to 2010s)

The promise: industrialize production by moving implementation to lower-cost labor at volume, with specs in one place and code produced in another.

Why it stalled: the model repeatedly ran into low code quality, communication and time-zone gaps, rework, and management overhead, with hidden costs that could add substantially to a project budget. The constraint moved to specification clarity and retained understanding, not headcount or hourly rate. The rhyme with spec debt in the AI era is exact.

• Four hidden costs of offshoring software development (Catalyte)

Low-code / no-code (2010s to today)

The promise: democratize application-building so non-technical users ship apps without writing code, the answer to the IT skills gap.

Why it stalled as a replacement: limited customization on complex or unique requirements, performance ceilings, vendor lock-in, and the recurring lesson that the hard part is design, not syntax. It found a real niche for simple internal apps; it did not eliminate engineers.

• Why the promise of low-code is deceiving (TechTarget)

Further reading

• The Eternal Promise: A History of Attempts to Eliminate Programmers (Turkovic) walks the whole COBOL-to-AI arc in one piece.
• IT snake oil: Six tech cure-alls that went bunk (InfoWorld)