{"course":{"slug":"how-software-changed","title":"How Software Development Changed","url":"https://addaly.com/learn/how-software-changed","level":"intermediate","track":"work"},"lesson":{"slug":"the-fifth-time-code-got-cheap","title":"The fifth time code got cheap","url":"https://addaly.com/learn/how-software-changed/the-fifth-time-code-got-cheap","position":2,"of":87,"minutes":9,"answer":"Every wave of cheaper code has attacked the difficulty of expressing intent and left the difficulty of deciding what should happen untouched.","keyIdea":"Every wave of cheaper code has attacked the difficulty of expressing intent and left the difficulty of deciding what should happen untouched, and the current wave differs mainly in that it fails confidently rather than loudly."},"body":{"format":"markdown","text":"## This has happened four times before\n\nThe claim that writing code has become cheap is true. It is also the fifth time it has been true, and the previous four are worth knowing, because each one came with the same prediction and the prediction was wrong in the same way.\n\n**Assemblers, late 1940s and 1950s.** Before them you wrote numeric opcodes. An assembler let you write `ADD` instead of an octal number and let the machine keep track of addresses. This was a genuine order-of-magnitude change in typing and errors. It was also resisted, on the grounds that real programmers knew the addresses.\n\n**FORTRAN, 1957.** John Backus's team at IBM spent about three years on the first compiler, and the pitch was explicit: programs would be written by the people who had the problem, not by programming specialists. The compiler produced code within striking distance of hand-written assembly, which was the technical achievement nobody expected. The social prediction (that programming as an occupation would shrink) did not happen.\n\n**COBOL, 1959.** Designed so that the statements read like English and a manager could check them. `SUBTRACT DISCOUNT FROM GROSS-PAY GIVING NET-PAY.` Managers did not, in the event, read the programs. COBOL instead created a profession that is still being paid, more than sixty-five years later, to maintain systems written in it.\n\n**Fourth-generation languages and CASE tools, 1980s.** Report generators, screen painters, diagram-to-code translators, and a promise summed up by the title of James Martin's 1982 book, *Application Development Without Programmers*. This wave mostly failed, and it failed on a specific rock: the tools removed the typing and left the deciding, and the deciding was the expensive part.\n\n**Frameworks, package managers and public Q&A, 2000s onward.** Rails claimed a blog in fifteen minutes and roughly delivered it. npm made installing more attractive than writing. Stack Overflow made the answer to the awkward question a search away. This was an enormous change, and it did what the earlier waves did: it changed the job rather than removing it. A large part of modern engineering is integrating and debugging other people's code, and that is what this wave produced.\n\n> Figure: Five times code got cheap. Timeline: Late 1940s, Assemblers replace numeric opcodes. Resisted on the grounds that real programmers knew the addresses.; 1957, FORTRAN. The pitch was that people with the problem would write the programs. The occupation grew instead.; 1959, COBOL is written to read like English so a manager can check it. Managers did not read the programs.; 1980s, Fourth-generation languages and CASE tools, marketed as application development without programmers. They removed the typing and left the deciding.; 2000s onward, Frameworks, package managers and public question sites. Much of the job became integrating and debugging other people's code.; Now, Generation. No new notation to learn, it reaches the long tail, and it fails confidently rather than loudly.. Every wave attacked the difficulty of expressing intent. None of them touched the difficulty of deciding what should happen, which is why the same prediction has now been falsified five times.\n\n## Brooks's distinction is still the one that works\n\nIn 1986 Fred Brooks wrote *No Silver Bullet*, and its central split explains all five waves. He separated **accidental** complexity (the difficulty of expressing your intent in the available medium) from **essential** complexity: the difficulty of the thing itself: working out what should happen, in every case, consistently, for people who disagree with each other.\n\nEvery wave above attacked accidental complexity. None touched the essential kind. Brooks's specific prediction was that no single development would within a decade give even one order-of-magnitude improvement in productivity, in reliability or in simplicity, and for the four decades since he has been broadly right.\n\nWhether he is right about this wave is contested and you should treat it as open. The honest statement is that the current wave attacks accidental complexity harder and more broadly than any previous one, and that if it turns out to reduce essential complexity as well, it will be the first thing that ever has.\n\n## Three things that are different\n\nBe fair to the present. Three differences are structural, not marketing.\n\n1. **There is no new notation to learn.** Every previous wave asked you to adopt a language. This one accepts the description you would give a colleague. That removes a barrier that kept the earlier waves inside the profession.\n2. **It covers the long tail.** A framework helps when your problem matches its shape. Outside that shape it is worse than nothing. A model will attempt anything, which is why it reaches work no framework ever did.\n3. **It fails differently.** A compiler that could not do something said so, precisely, with a line number. This wave produces a confident, well-formatted answer whether or not it is right.\n\nThe third difference is not a detail. It is the reason the rest of this course exists, because it breaks the review habits that four decades of the previous waves taught everybody.\n\n## What to take from the history\n\nThe prediction *programmers will not be needed* has now been made and falsified five times. That is not proof it is wrong a sixth time (an argument from history is weak evidence about a new mechanism) but it does mean the burden of proof sits with the person making it.\n\nThe more useful pattern is this: each wave removed a layer of work, demand expanded to fill the new capacity, and the job moved up a level of abstraction. The people who had a bad decade were not the ones displaced by the tool. They were the ones who defined their skill as the layer that got automated. Assembly programmers who learned FORTRAN were fine. Assembly programmers who insisted that compilers produced sloppy code were fine for about eight years.\n\nThat is the risk worth planning around, and it is a career question rather than an existential one."},"check":{"question":"Why did 1980s CASE tools and 4GLs, which really did generate working applications from diagrams and forms, fail to remove the need for programmers?","options":[{"text":"The generated code was too slow to run in production on the hardware of the time, so teams rewrote it by hand.","correct":false,"tempting":"Performance was a complaint but not the structural failure; FORTRAN faced the same objection and survived it because the underlying economics still worked."},{"text":"They removed the cost of expressing a decision and left the cost of making it, so the expensive part of the work was untouched.","correct":true},{"text":"They were proprietary and expensive, so adoption never reached the scale needed for the tools to improve.","correct":false,"tempting":"Mistakes a commercial condition for a technical limit; free and widely adopted successors hit the same wall."},{"text":"Programmers resisted them for professional reasons, in the same way early assemblers were resisted, and blocked adoption inside firms.","correct":false,"tempting":"Attributes to politics what the mechanism explains: the tools were adopted in many places and still did not remove the specification work."}]},"prev":{"slug":"the-cost-curve-moved","title":"The cost curve moved, but only part of it","url":"https://addaly.com/learn/how-software-changed/the-cost-curve-moved"},"next":{"slug":"induced-demand-for-software","title":"Cheaper software means more software","url":"https://addaly.com/learn/how-software-changed/induced-demand-for-software"},"authorship":"Founder and series editor: Dr Mustafa Mun. Written by AI models to a written standard. Exam keys checked blind by a second model: 3,665 of 3,666 agreed. Academic review invited.","review":{"status":"Draft, open for academic review"},"cite":"Addaly (2026) 'The fifth time code got cheap', in How Software Development Changed. Edited by M. Mun. Addaly. Available at: https://addaly.com/learn/how-software-changed/the-fifth-time-code-got-cheap (Accessed: 13 October 2026).","licence":{"name":"CC BY-NC-SA 4.0","url":"https://creativecommons.org/licenses/by-nc-sa/4.0/"},"reader":{"schema":1,"title":"The fifth time code got cheap","courseTitle":"How Software Development Changed","module":{"index":1,"slug":"where-the-cost-went","title":"Where the cost actually went"},"answer":null,"keyIdea":"Every wave of cheaper code has attacked the difficulty of expressing intent and left the difficulty of deciding what should happen untouched, and the current wave differs mainly in that it fails confidently rather than loudly.","hero":{"kind":"figure","figure":{"t":"figure","label":"Figure","figure":{"type":"timeline","title":"Five times code got cheap","events":[{"when":"Late 1940s","what":"Assemblers replace numeric opcodes. Resisted on the grounds that real programmers knew the addresses."},{"when":"1957","what":"FORTRAN. The pitch was that people with the problem would write the programs. The occupation grew instead."},{"when":"1959","what":"COBOL is written to read like English so a manager can check it. Managers did not read the programs."},{"when":"1980s","what":"Fourth-generation languages and CASE tools, marketed as application development without programmers. They removed the typing and left the deciding."},{"when":"2000s onward","what":"Frameworks, package managers and public question sites. Much of the job became integrating and debugging other people’s code."},{"when":"Now","what":"Generation. No new notation to learn, it reaches the long tail, and it fails confidently rather than loudly."}],"caption":"Every wave attacked the difficulty of expressing intent. None of them touched the difficulty of deciding what should happen, which is why the same prediction has now been falsified five times."},"alt":"Figure: Five times code got cheap. Timeline: Late 1940s, Assemblers replace numeric opcodes. Resisted on the grounds that real programmers knew the addresses.; 1957, FORTRAN. The pitch was that people with the problem would write the programs. The occupation grew instead.; 1959, COBOL is written to read like English so a manager can check it. Managers did not read the programs.; 1980s, Fourth-generation languages and CASE tools, marketed as application development without programmers. They removed the typing and left the deciding.; 2000s onward, Frameworks, package managers and public question sites. Much of the job became integrating and debugging other people’s code.; Now, Generation. No new notation to learn, it reaches the long tail, and it fails confidently rather than loudly.. Every wave attacked the difficulty of expressing intent. None of them touched the difficulty of deciding what should happen, which is why the same prediction has now been falsified five times."}},"blocks":[{"t":"h2","id":"this-has-happened-four-times-before","runs":[{"text":"This has happened four times before"}]},{"t":"p","runs":[{"text":"The claim that writing code has become cheap is true. It is also the fifth time it has been true, and the previous four are worth knowing, because each one came with the same prediction and the prediction was wrong in the same way."}]},{"t":"p","runs":[{"text":"Assemblers, late 1940s and 1950s.","b":true},{"text":" Before them you wrote numeric opcodes. An assembler let you write "},{"text":"ADD","code":true},{"text":" instead of an octal number and let the machine keep track of addresses. This was a genuine order-of-magnitude change in typing and errors. It was also resisted, on the grounds that real programmers knew the addresses."}]},{"t":"p","runs":[{"text":"FORTRAN, 1957.","b":true},{"text":" John Backus’s team at IBM spent about three years on the first compiler, and the pitch was explicit: programs would be written by the people who had the problem, not by programming specialists. The compiler produced code within striking distance of hand-written assembly, which was the technical achievement nobody expected. The social prediction (that programming as an occupation would shrink) did not happen."}]},{"t":"p","runs":[{"text":"COBOL, 1959.","b":true},{"text":" Designed so that the statements read like English and a manager could check them. "},{"text":"SUBTRACT DISCOUNT FROM GROSS-PAY GIVING NET-PAY.","code":true},{"text":" Managers did not, in the event, read the programs. COBOL instead created a profession that is still being paid, more than sixty-five years later, to maintain systems written in it."}]},{"t":"p","runs":[{"text":"Fourth-generation languages and CASE tools, 1980s.","b":true},{"text":" Report generators, screen painters, diagram-to-code translators, and a promise summed up by the title of James Martin’s 1982 book, "},{"text":"Application Development Without Programmers","i":true},{"text":". This wave mostly failed, and it failed on a specific rock: the tools removed the typing and left the deciding, and the deciding was the expensive part."}]},{"t":"p","runs":[{"text":"Frameworks, package managers and public Q&A, 2000s onward.","b":true},{"text":" Rails claimed a blog in fifteen minutes and roughly delivered it. npm made installing more attractive than writing. Stack Overflow made the answer to the awkward question a search away. This was an enormous change, and it did what the earlier waves did: it changed the job rather than removing it. A large part of modern engineering is integrating and debugging other people’s code, and that is what this wave produced."}]},{"t":"h2","id":"brooks-s-distinction-is-still-the-one-that-works","runs":[{"text":"Brooks’s distinction is still the one that works"}]},{"t":"p","runs":[{"text":"In 1986 Fred Brooks wrote "},{"text":"No Silver Bullet","i":true},{"text":", and its central split explains all five waves. He separated "},{"text":"accidental","b":true},{"text":" complexity (the difficulty of expressing your intent in the available medium) from "},{"text":"essential","b":true},{"text":" complexity: the difficulty of the thing itself: working out what should happen, in every case, consistently, for people who disagree with each other."}]},{"t":"p","runs":[{"text":"Every wave above attacked accidental complexity. None touched the essential kind. Brooks’s specific prediction was that no single development would within a decade give even one order-of-magnitude improvement in productivity, in reliability or in simplicity, and for the four decades since he has been broadly right."}]},{"t":"p","runs":[{"text":"Whether he is right about this wave is contested and you should treat it as open. The honest statement is that the current wave attacks accidental complexity harder and more broadly than any previous one, and that if it turns out to reduce essential complexity as well, it will be the first thing that ever has."}]},{"t":"h2","id":"three-things-that-are-different","runs":[{"text":"Three things that are different"}]},{"t":"p","runs":[{"text":"Be fair to the present. Three differences are structural, not marketing."}]},{"t":"ol","start":1,"items":[[{"text":"There is no new notation to learn.","b":true},{"text":" Every previous wave asked you to adopt a language. This one accepts the description you would give a colleague. That removes a barrier that kept the earlier waves inside the profession."}],[{"text":"It covers the long tail.","b":true},{"text":" A framework helps when your problem matches its shape. Outside that shape it is worse than nothing. A model will attempt anything, which is why it reaches work no framework ever did."}],[{"text":"It fails differently.","b":true},{"text":" A compiler that could not do something said so, precisely, with a line number. This wave produces a confident, well-formatted answer whether or not it is right."}]]},{"t":"p","runs":[{"text":"The third difference is not a detail. It is the reason the rest of this course exists, because it breaks the review habits that four decades of the previous waves taught everybody."}]},{"t":"h2","id":"what-to-take-from-the-history","runs":[{"text":"What to take from the history"}]},{"t":"p","runs":[{"text":"The prediction "},{"text":"programmers will not be needed","i":true},{"text":" has now been made and falsified five times. That is not proof it is wrong a sixth time (an argument from history is weak evidence about a new mechanism) but it does mean the burden of proof sits with the person making it."}]},{"t":"p","runs":[{"text":"The more useful pattern is this: each wave removed a layer of work, demand expanded to fill the new capacity, and the job moved up a level of abstraction. The people who had a bad decade were not the ones displaced by the tool. They were the ones who defined their skill as the layer that got automated. Assembly programmers who learned FORTRAN were fine. Assembly programmers who insisted that compilers produced sloppy code were fine for about eight years."}]},{"t":"p","runs":[{"text":"That is the risk worth planning around, and it is a career question rather than an existential one."}]}],"check":{"question":[{"text":"Why did 1980s CASE tools and 4GLs, which really did generate working applications from diagrams and forms, fail to remove the need for programmers?"}],"options":[{"text":[{"text":"The generated code was too slow to run in production on the hardware of the time, so teams rewrote it by hand."}],"correct":false,"tempting":[{"text":"Performance was a complaint but not the structural failure; FORTRAN faced the same objection and survived it because the underlying economics still worked."}]},{"text":[{"text":"They removed the cost of expressing a decision and left the cost of making it, so the expensive part of the work was untouched."}],"correct":true,"tempting":null},{"text":[{"text":"They were proprietary and expensive, so adoption never reached the scale needed for the tools to improve."}],"correct":false,"tempting":[{"text":"Mistakes a commercial condition for a technical limit; free and widely adopted successors hit the same wall."}]},{"text":[{"text":"Programmers resisted them for professional reasons, in the same way early assemblers were resisted, and blocked adoption inside firms."}],"correct":false,"tempting":[{"text":"Attributes to politics what the mechanism explains: the tools were adopted in many places and still did not remove the specification work."}]}],"order":[2,0,1,3],"why":null},"prev":{"slug":"the-cost-curve-moved","title":"The cost curve moved, but only part of it","minutes":8},"next":{"slug":"induced-demand-for-software","title":"Cheaper software means more software","minutes":9}}}