What would this have cost?
This platform exists. It is running, it is measurable, and it was built in four days by one resident working with AI assistants. So we can ask a question that is normally hypothetical in both directions at once: what would the identical amount of work have cost a government to procure, in each language it might plausibly have been written in?
Every language, priced
Same work, same rate, same model. Sorted by what it would cost the public. The row in colour is the language mix this platform is actually written in.
| Language | Dominance | Lines | Months | Cost |
|---|
model Every figure in this table is an estimate produced by the method described under Method. The line counts come from published gearing ratios that disagree with each other by up to 40%; the cost comes from COCOMO II, an estimating model built from other people's projects. These numbers are good for comparing languages to each other. They are not quotes.
And what it actually cost
A number this page got wrong
—
The comparison is not fair and is not meant to be. A procured system carries requirements gathering, security review, accessibility audit, procurement law, acceptance testing, and a warranty — real work this project has done unevenly or not at all. The honest claim is narrower and still large: the cost of producing working civic software has moved, and public procurement has not noticed.
The same program, twenty-five times
Estimating models are somebody else's averages. So this page ships its own measurement: one program — a public-records deadline tracker, the smallest honest slice of what this platform does — written once in every language on the list, to a single specification. No date libraries and no library sort, because a 1959 language does not get one and the comparison has to be fair.
Then it is counted. Blank lines and comments are excluded, so nobody's language wins by being terse about explaining itself.
Lines of code, counted
measured These are counted, not estimated — the files are in this folder and you can count them yourself. COBOL needs about three and a half times the code of Python to do the identical job. That ordering matches the published gearing ratios closely enough to trust the ratios for languages nobody here can compile.
Read it
Pick a language. This is the actual file, served from this folder.
Select a language above.
What "verified" means here
A language marked verified was compiled and run on the machine that generated this page, and its output matched the reference byte for byte. The rest were written to the same specification but there was no compiler on hand — treat their line counts as good and their correctness as unproven. The distinction is recorded per language rather than smoothed over, because a page arguing for transparency in other people's software does not get to be vague about its own.
What the public actually spends
Everything above is a model. This is not. These figures come from USAspending.gov, the federal spending database published under the DATA Act, pulled by a script in this repository that anyone can re-run.
Obligations by fiscal year
NAICS 541511 / 541512 / 541519 — custom programming, systems design, and related services. Prime contract awards only.
Publishers, resellers, integrators
Named-vendor totals over the same window and the same award types. Read this chart with its limitation in hand, because the limitation is the finding.
Why the software publisher's number looks small
—
The largest awards in the window
| Recipient | Agency | Amount |
|---|
Every row links to its record on USAspending. An award's face value is not the same as money spent — it is what the government committed to, and large vehicles are drawn down over years.
What it bought
Federal totals do not reach the place most people meet government software: a county office, a state benefits line, a school district. Those systems are procured locally and fail locally, and the record of them lives in audits and court files rather than in an API. This ledger is hand-assembled and hand-cited.
reported Each entry names the auditor, court, or newsroom that published the figure. None of them has yet been checked against the underlying primary document by anyone on this project, and each entry says so in its own record. That is a weaker standard than the rest of this page and it is labelled rather than hidden.
The other column
A page that only lists failures is an argument, not a ledger. These are public bodies that went the other way — and one that went the other way and then turned back, kept here precisely because it cuts against the case being made.
How the numbers are made
Three kinds of number appear on this page and they are not equally reliable. Every figure carries a tag saying which kind it is.
measured Counted on this machine. The kernel line counts, the platform's own source, the page and word counts of the published volumes, and the federal award data pulled from USAspending. Re-derivable from the files in this repository.
model Produced by an estimating model. Every cost, effort, and "lines you would write" figure. Explained below, with its failure modes.
reported Somebody else's published figure. The state and municipal ledger. Attributed, not adopted.
Step 1 — measure what exists
The platform's source is counted by language, excluding blanks, comments, dependencies, and generated files. Data files and prose are counted separately and never priced: a national database dump is not a programming achievement and must not inflate a line count that then gets multiplied by a wage.
Step 2 — convert lines to function points
A function point is a unit of delivered functionality, independent of language. Going from lines back to function points is called backfiring, and it uses published gearing ratios — average lines of code per function point, per language. This page uses the QSM and Capers Jones tables, which disagree with each other by up to 40% on the same language. That disagreement is carried through as a range rather than averaged away.
Step 3 — convert function points back into the target language
Multiply by that language's gearing ratio. This is where COBOL gets expensive and Python gets cheap, and it is the step doing most of the work in every headline on this page. Languages that postdate the published tables — Swift, Go, Rust, Kotlin, TypeScript, FutureBASIC — are marked interpolated in the language file, with the relative they were derived from named. Treat those as an argument, not a measurement.
Step 4 — convert size into effort and money
COCOMO II, the standard public estimating model: effort in person-months = 2.94 × (thousands of lines)1.10, times a difficulty multiplier, with schedule = 3.67 × effort0.318. Cost is effort times a loaded monthly labour rate, which the slider controls. The default of $175/hour is in the range of published federal IT labour categories, but it is a dial, not a finding — move it and watch every number move with it.
Where this is wrong
Backfiring is a blunt instrument. It answers "is this language roughly twice the code, or roughly six times" well. It does not answer "how many lines exactly" at all.
COCOMO II was calibrated on procured projects. Feeding it a four-day AI-assisted build and reading the output as what that build "should" have cost is precisely the error this page is accusing procurement of. The model says what a conventional team would have been billed. That is the comparison being drawn, and it is the only one it supports.
Line count is not value. A language that needs three times the code is not three times worse, and terseness is not virtue. What the ratio measures is how much human attention a maintenance decade will demand — which is exactly what a public body is signing up for, and exactly what is missing from the bid.
The kernel is small. Twenty-five implementations of a fifty-to-two-hundred line program is real evidence about verbosity and no evidence at all about how these languages behave at a hundred thousand lines.
Names, cleared up
- COBOL — not "Cobalt"
- COmmon Business-Oriented Language, 1959. Cobalt is a metal. The confusion is worth keeping in mind when reading procurement documents, where the language is often named by people who have never seen it and are approving its replacement.
- Xcode and "Apple Code" — not languages
- Xcode is Apple's development environment, a tool for writing programs. The languages it writes are Objective-C and Swift, both in the table. The distinction matters here because the lock-in is in the tool and the store, not in the language: Swift's compiler is open source and runs anywhere, and you still cannot put an app on a resident's iPhone without Apple's permission.
- Visual Basic, VB.NET, VBA and VBScript
- Four different things sold under one brand across thirty years. VB6 (1998) is the one that ran the county offices and was retired in 2008. VB.NET is a different language on a different runtime, and Microsoft stopped adding features to it in 2020. Both are in the table separately, because a migration between them was a real bill somebody paid.
- FutureBASIC
- A commercial BASIC compiler for the Macintosh, made freely available in 2008 and maintained by volunteers since. In the table because it is the honest answer to what happened to small Mac developers before app stores — the vendor gave up and the community kept the compiler alive. That is the model this project is arguing for, and it is fair to note it is also a model that has never had to survive a procurement.
- Function point
- A unit of delivered functionality — inputs, outputs, queries, files, interfaces — counted independently of how it is implemented. The only reasonable way to compare a COBOL system with a Python one.
Sources and how to check
Contract data: api.usaspending.gov, refreshed by scripts/rosetta_ingest.py. Public, no key, no login.
Gearing ratios: the QSM function point languages table and Capers Jones' programming languages table, both published. Each language's entry records which one it came from and whether it was interpolated.
The kernel: static/rosetta/kernel/ — twenty-five source files, one specification, one expected output.
The volumes: page and word counts read from the Bookstar catalogue, so the shop and this page can never disagree. See the record itself.
What this page does not claim. This is an argument about procurement: who public money goes to, what it buys, and what the alternatives cost. It makes no claim about the private conduct of any individual associated with any company named here, and none of the figures above should be read as implying one. Where people want to examine what has been alleged about a named person, the place for that is a court record or a published deposition, read directly and in full — not a chart on a cost page. Keeping those two things apart is not timidity. An argument about $541 billion in procurement stands on its own evidence, and mixing it with anything weaker is how a solid case gets dismissed as something else.
Corrections wanted. Every number here has a path back to a file in a public repository. If one of them is wrong — a gearing ratio, an award total, a figure in the ledger, a language that is misdescribed — that is a bug, and it is worth more to this project than agreement. requests@everythingisperfect.org.