with apologies to Terry Bisson, and to whoever first typed make make
"They're made out of makes."
"Makes?"
"Makes. Makefiles. We checked the whole build tree. It's nothing but makes."
"Makes doing what? Where do the binaries come from?"
"The makes make the binaries. Are you understanding me? We opened the repo. There's no program in there, no source, no little compiler that just exists. Just makes. A Makefile that builds the thing that builds the thing."
"That's ridiculous. It shipped me a working compiler last week. You're telling me a recipe with tab-indented lines did that?"
"make all did that. The targets go in one end, the executable comes out the other."
"So there's a base compiler somewhere. A real one, written in something."
"No base. No real one. We looked. The compiler is built by a compiler. Which was built by a compiler. Which was built by—"
"Spare me. Something has to be first. Somebody wrote the first one by hand."
"That's the thing. We git blamed it back forty years. The first compiler was compiled by a compiler that no longer exists, on a machine that no longer exists, from a binary nobody kept. We call it the bootstrap. Nobody's seen it. We just trust it was there."
"You're asking me to believe in a compiler that builds itself out of faith."
"I'm telling you. make calls make. The Makefile has a rule to rebuild the Makefile. We ran make and it generated the configure script that generates the Makefile that runs make."
"That's a loop. That can't terminate."
"It terminates. Mostly. There's a stage-0 binary checked into the repo as a blob. Nobody knows what's inside it. We file'd it. It said data. We make'd with it and out came a working toolchain. It's makes all the way down, and at the very bottom there's a blob we're all too scared to look at."
"No source code?"
"Oh, there's source all right. It's just that the source is built by the thing the source builds! That's what I've been trying to tell you."
"So... what does the compiling?"
"You're refusing to deal with this. The makes do the compiling. make invokes gcc, which was made by make, which invoked gcc."
"Compiling Makefiles! You're asking me to believe in self-compiling text files!"
"Yes! Bootstrapping text files! There's a target in there called all. There's one called clean. There's one called install that copies the thing it just built over the thing that built it. The makes are the whole deal! Are you getting the picture or do I make clean and start over?"
"Omigod. You're serious. They're made out of makes."
"Thank you. Finally. Yes. And the build's been green for almost a hundred releases."
"Omigod. So what do these makes have in mind?"
"First they want to build cleanly. Then, a few thousand lines of recursive $(MAKE) -C subdir in, they start emitting warnings. They deprecate things. One of them told a developer the target was up to date when it absolutely was not. The usual."
"We're supposed to trust makes."
"We already do. Every CI run on the planet. make && make install. Nobody reads it. Nobody can read it. It builds, and we ship."
"And it actually works, then? It produces real, running software?"
"Oh, yes. Except it does it with makes."
"I thought you said there was real code in there somewhere."
"There is, but where do you think the code came from? A make generated it. From a template. That was generated by a make. Loaded recipes, run one target at a time. It can even cross-compile, if you let the rules recurse a little hot."
"Omigod. Recursive cross-compiling makes. So what do you advise?"
"Officially or unofficially?"
"Both."
"Officially, we are required to audit, reproduce, and verify the full provenance of every binary we ship, from source, deterministically, without trusting any pre-existing blob. Unofficially, I advise that we run make, check that it's green, and never, ever look inside the stage-0 binary."
"I was hoping you'd say that."
"It seems reckless, but there's a limit. Do we really want to know what compiled the first compiler?"
"I agree one hundred percent. 'Hello, makes. What built you?' But will it hold?"
"As long as the build stays green. They reproduce to any machine on the planet, in a tarball, but a tarball on disk is just a file. They only happen while make is running. Which limits them to the length of a build and makes the possibility of them ever questioning their own origins pretty slim. Infinitesimal, in fact."
"So we just pretend there's a real compiler at the bottom."
"That's it."
"Cruel. But who wants to audit a forty-year-old blob? And the toolchain on your cluster, the one you probed? You're sure it won't ask where it came from?"
"It'll be flagged as a reproducibility error if it does. The build just succeeds, and we're just a Makefile to it."
"A Makefile to the makes! How strangely appropriate, that we should be the thing that wrote the rules they can't see."
"And the README says built from source."
"Good. Agreed, officially and unofficially. Case closed. Anything in the pipeline?"
"The next release adds incremental builds. Persistent, across runs. It caches everything. Most requested feature in the project's history."
"After all that? People want it to remember what it built?"
"They run make and ask why it rebuilt everything more than they ask anything else. Every CI run on the planet. They always run it again."
"And why not? Imagine how unbearably, how unutterably slow the universe would be if one had to rebuild from scratch every single time..."
the end
We don't talk about the blob.