[matheusmoreira]

No doubt. The second attempt is always better. My initial plan was to write a complete first implementation in C so that it's always possible to bootstrap the language, then write a compiler inside the lisp itself, or write a Rust version. Hope I somehow manage to do it all before I die of old age.

[exe34]

Aha I've been semi-vibe-coding a scheme for esp32c3 and linux at the same time, and forgoing the libc too, so baremetal c. I went with a slightly awkward approach for allocation, with heap being seen as pages, and within pages, fixed size objects of size 8, 16 or 32 bytes. A pair is two words, and either bitpacked or pointer to another object. I'm not far in, vaguely following the Peter Michaux approach.

[zabzonk]

> The second attempt is always better.

Um, see The Second System Effect.

https://en.wikipedia.org/wiki/Second-system_effect

[matheusmoreira]

Lone itself is a second system: it's the spiritual successor of liblinux. I suppose the scope did increase... I'll try to be careful.

[mpyne]

In fairness, with the waterfall methodology that pervaded back then, the "first" system you shipped was actually the second. "Build one to throwaway; you will, anyhow".

[db48x]

Actual waterfall development was far more iterative than most people realize. If you want a primary source, I recommend Sunbust and Luminary by Don Eyles. It recounts the development of the software for the Apollo lunar lander.

[mpyne]

Then it wasn't "actual waterfall development". The paper that defined waterfall literally tells you that you will build the system twice. Ideally only twice. You can refer to Dr. Royce's paper as the primary source on that.

It is heartening to know that iterative development has been commonplace since long before the agile manifesto was written though, to make it clear that it has long been used and long been successful.

[db48x]

Royce’s paper has a critical flaw. It assumes that a released system can be put into operation once and then run forever. There are cases where this is true, but real life offers more variation than that. In the case of the Luminary, the initial release was for Apollo 10. That was the mission that did the dress rehearsal for landing, sending an unmanned Lunar Module most of the way through the landing sequence before aborting and returning to orbit. But there were seven additional missions after that, Apollo 11 through Apollo 17, and they took the opportunity to update Luminary for each of them based on feedback from the prior missions.

Don Eyles even produced an updated version _after_ the Apollo 17 version was released, but before Apollo 17 flew, just to test a theory about how to make the software more responsive during the final landing when a human was actually selecting a landing site. Of course that version required changing the requirements, which in true Waterfall style were part of the contract his company had signed with NASA years before!

And even inside of a single waterfall cycle there is feedback from both automated and manual testing. Luminary was run in a simulator running on a supercomputer that simulated various landing conditions. It had to pass those simulations before it ever had a hope of being used in space. Eyles calls that “unfortunate”, but the reality is that it is simply necessary.

And then there was the manual testing, which NASA did on grand scale for the Apollo missions. They made an accurate 3D model of the terrain near the landing sites on a table. This table hung upside down in a hangar in Houston. A television camera was mounted on a six–axis mount below the terrain model. The mount was controlled by signals from a Lunar Module simulator used by the astronauts, and the image from the camera was fed to the screens outside the windows of the LM simulator. As the astronauts flew the simulator the camera moved along the same path, providing the astronauts with accurate real–time visuals. The LM simulator had a real AGC and ran the most up–to–date version of Luminary as the astronauts practiced their landings. Several improvements to Luminary resulted from feedback provided by each crew as they practiced.

Fundamentally Waterfall discourages iteration because it sees it as a waste of time and money. Ultimately this is because back then releasing software was expensive. Luminary had to be sewn, by hand, into a core memory rope before it could be installed in the spacecraft. Iteration could only happen on that scale because NASA had already planned multiple moon landings. Iteration in the simulators was much easier and cheaper though because they could load the software from disk drives. Those drives were the size of a washing machine though, and could never be flown in space.

The assumption that it is cheaper to fix bugs in the specification before you ever write any software was based on numbers gathered from software development done for the US Air Force. It turns out that if you detect a bug in your missile’s flight software _after_ you have manufactured hundreds of thousands of missiles for the Air Force then yes, fixing that defect is very expensive. You really would rather have found the problem earlier in the development process. But today we can release a new version of our software to hundreds of millions of users around the world with the press of a button. The assumption simply no longer holds so iteration should not be seen as “unfortunate” any more.

[mpyne]

Yes, and this is much of my lament. The DoD mindset pervaded a lot of places building significant software systems in early computing, as compared to NASA and others.

I don't think iteration should have been considered unfortunate even back then, but it was. And by the time the DoD started to realize iteration was not only required, but helpful (no later than the mid-1980s with a Defense Science Board report on software acquisition methods initiated by Dr. Fred Brooks), the waterfall methods had more or less infested all of DoD software acquisition.

Even worse (for DoD), this was occurring even as DoD's organic ability to develop software-based systems was atrophying, so they needed their contracting/acquisition process to lead to successful software delivery more than ever before. Had DoD had a solid internal iterative software development process they could fall back on they'd have been in much less of a pickle.