CameleeringCameleering / Wirth's law
Cameleering · the lineage
Wirth's law in 2026: measured
In 1995 Niklaus Wirth wrote that software was getting slower more rapidly than hardware was getting faster. Thirty years later we can check the claim against numbers: how much bigger software got, how much faster hardware got, and what users wait for. The answer is not as simple as the slogan, which is a reason to measure.
No claim without a number.
The law and its family
- Wirth's law. In "A Plea for Lean Software" (IEEE Computer, February 1995) Wirth argued that software grows because hardware lets it, and because customers cannot tell essential features from nice-to-have ones. He credited the line about software slowing faster than hardware speeds up to Martin Reiser [1][2]. His own counter-example was Oberon, a complete system designed to be small.
- Gates's law and May's law make the same point with a number: software efficiency halves every 18 months, cancelling out Moore's law [2].
- Page's law, named by Sergey Brin after Larry Page in 2009, says the same of software speed [2].
Software got bigger: the measurements
| measure | then | now | change |
|---|---|---|---|
| median web page weight, mobile [3] | 505 KB (2014) | 2,311 KB (2024) | 4.6x |
| median web page weight, desktop [3] | 1,208 KB (2014) | 2,652 KB (2024) | 2.2x |
| median JavaScript on a mobile home page [3] | — | 558 KB (2024) | +14% in one year |
| keypress to screen, Apple IIe (1983) vs modern machines [4] | 30 ms | 50–200 ms | slower |
| Linux kernel source, lines [5] | about 20 M (2015) | 40 M (2025) | about 2x |
Caveats from the sources: Dan Luu's latency figures depend on the terminal and display refresh rate (a 165 Hz desktop measured 50 ms); the kernel count includes comments, blank lines and drivers a given machine never loads. Page weight is the most direct measure of growth, because it is downloaded and parsed on every visit.
Hardware stopped getting faster for free
- Single-processor performance grew about 52% a year from 1986 to 2003, and only about 3.5% a year recently: a doubling roughly every 20 years instead of every two [6]. Hennessy and Patterson's Turing lecture reported about 3% in a single recent year [7].
- Memory and storage kept getting cheaper per byte for decades [8], which made it easy to spend bytes.
So the free ride Wirth described has changed shape. Bytes are still cheap, but a single core is barely faster each year, so software that does more work per request now costs real time, and in the cloud, real money (code efficiency as a FinOps lever).
The counter-argument
"Hardware is cheap, programmers are expensive"
Jeff Atwood argued in 2008 that buying hardware should come first: Stack Overflow's servers cost about $5,000, less than a month of a programmer [9]. For one team running its own servers, that is often right, and he added his own caveats: hardware cannot save you from bad code, and code that runs on users' machines is a different case.
Where it stops holding
The cost of slow software is paid once per machine, per user, per request. For a library or product that runs on thousands of machines, or for cloud services billed by the second, that sum quickly exceeds the engineering time to fix it, as readers of Atwood's own post pointed out [10].
What cameleering takes from Wirth
Wirth's answer was a lean system built by design. Cameleering adds a measurement: take software that many people already run, make it carry the same load on less, and publish the before and after, losses included. Cameleer is the first case, an integration engine that starts in 3 ms where Apache Camel on Java 21 took 1.1 s on the same machines (the ledger).
Common questions
What is Wirth's law?
The observation that software is getting slower more rapidly than hardware is getting faster, from Niklaus Wirth's 1995 article "A Plea for Lean Software" in IEEE Computer. Wirth credited the line to Martin Reiser.
Is Wirth's law still true?
In parts. Software kept growing: the median mobile web page is about 4.6 times heavier than in 2014, and Dan Luu measured keypress-to-screen latency of 50 to 200 ms on modern machines against 30 ms on a 1983 Apple IIe. Meanwhile single-core speed now improves only a few percent a year, so growth in software work shows up directly as time and cost.
Why is modern software slow?
Mostly because it does more work and carries more code than the task needs: larger pages and scripts, more layers and dependencies, and waiting hidden behind loaders. Hardware used to hide much of it; single-core speed no longer grows fast enough to do so.
Is hardware cheaper than optimizing code?
For a single team's own servers it often is, as Jeff Atwood argued in 2008. For software that runs on many machines or is billed per second in the cloud, the cost of inefficiency is multiplied by every instance and request, and fixing the software usually wins.
Sources
Checked on 2026-11-12.
- Niklaus Wirth, "A Plea for Lean Software", IEEE Computer 28(2):64–68, February 1995, doi:10.1109/2.348001.
- Wikipedia, Wirth's law (the law's wording, Reiser's preface, Gates's, May's and Page's laws).
- HTTP Archive, Web Almanac 2024: Page Weight.
- Dan Luu, "Computer latency: 1977–2017", 2017.
- Tom's Hardware, "Linux kernel source expands beyond 40 million lines", January 2025.
- Hennessy and Patterson, Computer Architecture: A Quantitative Approach, chapter 1.
- ACM SIGARCH, "John Hennessy and David Patterson share ACM Turing Award".
- Our World in Data, Historical cost of computer memory and storage (after John C. McCallum's series).
- Jeff Atwood, "Hardware is Cheap, Programmers are Expensive", 18 December 2008.
- Coding Horror discussion, "Hardware is Cheap, Programmers are Expensive".