5 ms·
Dr. Margaret Hamilton coined the term while developing the software for Apollo 11. She went on to design a system that permitted bug-free software development
by carapace 7y ago
Dr. Margaret Hamilton coined the term while developing the software for Apollo 11. She went on to design a system that permitted bug-free software development ("Higher Order Software" or HOS) and attempted to market it. It was panned by e.g. the Navy and Dijkstra, and languishes in obscurity to this day.
The basic details of the system are described in a book called "System design from provably correct constructs: the beginnings of true software engineering" by James Martin (he mentions Hamilton in the references.)
In modern terms you work directly with an AST and the UI only permits modifications by operations that preserve the correctness of the AST. It eliminates all sources of bugs, and it was simple enough to teach normal people to use it with just some coaching.
Anyhow, that's "software engineering". The rest of us are just pushing text around in buffers and hoping it isn't broken. There are a few people using math to make software, and it works out really well (E.g. https://www.categoricaldata.net/ https://www.categoricaldata.net/), but mostly "software engineering" as it is usually used is an oxymoron.
- skybrian 7y agoThe claim that a "correct AST" would eliminate all sources of bugs is unreasonably bold, and I wonder if they really made that claim, or you misunderstood something? That just means the code compiles. Some languages are stricter than others, but none claim to eliminate all bugs. Static analysis and safe refactoring tools are great, but they are certainly not going to protect you from implementing the wrong thing because you misunderstood the requirements or the environment; that's not possible even in principle. At best you can check for consistency (for example, consistency between a specification and its implementation).
- Jwarder 7y ago> you work directly with an AST and the UI only permits modifications by operations that preserve the correctness of the AST. It eliminates all sources of bugs With the caveat up front that I know nothing about this beyond what you have written: wouldn't this just catch compilation bugs? The compiler tells me if the blob of text I gave it is incorrect in terms of any syntax errors. Business logic bugs and accounting for bogus data seem more important to me.
- carapace 7y agoYes, you and skybrian have got the idea. It wasn't magic, it just prevented entire categories of preventable bugs, syntax and semantics. You could still use it to write correct programs that did the wrong thing. In other words, it couldn't catch bugs that occur "between the keyboard and the chair". FWIW the tech has a bit of a Wikipedia page now: https://en.wikipedia.org/wiki/Universal_Systems_Language https://en.wikipedia.org/wiki/Universal_Systems_Language but it doesn't seem very informative to me. YMMV
- eitland 7y agoOk, so you admit this was wild hyperbole: > It eliminates all sources of bugs,
- carapace 7y agoHyperbole, yes, wild, no. My problem is I've been trying to get traction on this for years and no one is interested. (Although type-checking is finally getting some love. It's not all doom and gloom out there.) Most bugs could be prevented or eliminated automatically.† If we're not doing that then in what sense are we entitled to call ourselves "engineers"? (Just to bring it back around to the topic.) I mean, our bridges collapse all the time. This is not science? †See Alice Pascal https://www.templetons.com/brad/alice.html https://www.templetons.com/brad/alice.html > In a syntax directed editor, you edit a program, not a piece of text. The editor works directly on the program as a tree -- matching the syntax trees by which the language is structured. The units you work with are not lines and chracters (sic) but terms, expressions, statements and blocks. This is still just syntactic correctness, you can only enter syntactically-correct Pascal programs, no typos either, but I don't think it did type-checking or anything like that. But it illustrates my point that if you're typing text into an editor and hoping it correctly describes a computer program, you're doing it wrong.
- goto11 7y agoYou might have a good case, but the way you present it makes it seem very disconnected from real-world development. Equating the most trivial kind of errors (which are caught by the compiler anyway) with "all sources of bugs" ignores the kind of bugs which are actually hard to prevent and might slip into production. But these are the kind of bugs developers are actually concerned about. Preventing editors from saving a file with a typo in it is a solution to a non-problem. If you want to interest people in these ideas, you should show how it can solve real problems.
- goto11 7y agoDijkstras criticism is pretty revealing: > The overwhelming impression is that the authors have had more experience than education. Yes, Hamilton worked on the software which literally put a man on the moon. But apparently this is worthless to Dijkstra since they doesn't use the correct academic jargon. https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD852.html https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...
- carapace 7y agoI'm folding in responses to your other comments here. Well met BTW. - - - - You found Dijkstra's review. I'm a fan of his but the guy was hugely arrogant. IMO he craps on them pretty harshly. I can kind of see where he's coming from, but "he doesn't get it" IMO. He misses the point (or maybe HOS sucked compared to what was later described in Martin's book...) - - - - FWIW, James Martin went on to write "System Design from Provably Correct Constructs: The Beginnings of True Software Engineering" which is where I learned about all this. I don't actually know much about HOS specifically, only what's in that book. If you're interested that's the thing to read. - - - - > So how does this prevent any bugs which aren't already prevented by the language? The UI would not let the user enter syntactically nor semantically incorrect "trees". In modern terms, if you had a syntax-oriented editor (like Alice Pascal) for a language with good type-checking I think you would have most of what HOS et. al. was or did. At the time of Apollo 11 (circa 1969), type-checking was barely a thing: > In 1969 J. Roger Hindley extended this work and proved that their algorithm always inferred the most general type. https://en.wikipedia.org/wiki/Type_inference#Hindley%E2%80%93Milner_type_inference_algorithm https://en.wikipedia.org/wiki/Type_inference#Hindley%E2%80%9... - - - - > Equating the most trivial kind of errors (which are caught by the compiler anyway) with "all sources of bugs" ignores the kind of bugs which are actually hard to prevent and might slip into production. Yes, I know, sorry. I admitted that "all sources of bugs" was hyperbole. I was going for rhetorical effect. > caught by the compiler anyway First, why wait? If the errors cannot be committed in the first place surely that's better than detecting them only at compile-time? Second, compilers didn't catch those errors back in the day. The whole reason Dr. Hamilton made up this stuff was because existing methods, tools, and technology would have crashed her spaceship. > ignores the kind of bugs which are actually hard to prevent and might slip into production Every moment saved by the machine is a moment the humans can use to prevent or detect the errors the machine can't detect automatically. Here we are back to Dijksra. You know he only got a physical computer when his colleagues forced him to get a Mac so they could email him, eh? He held, and I agree, that the kind of errors you're talking about do not happen while typing in the software. They occur "between the keyboard and the chair". If I may wiggle a little, I think of "bugs" as glitches in the machine, while the kind of errors you're talking about I think of as just "errors". But I know that's idiosyncratic, and that most people lump them together as just "bugs". The only thing you can do about them is think clearly. - - - - The original question of this subthread was, "What is software engineering, anyway?" My answer is, "What Margaret Hamilton did." My point is that we have had tools that systematically eliminate sources of error. All automatically preventable bugs should be prevented (modulus economic consideration, but here costs would be trivial for automation of error prevention and the benefits and cost saving would be pretty high.) Otherwise, calling ourselves "engineers" is pretty lame. IMO. - - - - > If you want to interest people in these ideas, you should show how it can solve real problems. Real problems, eh? :-) Sending a spaceship to the moon? And getting it back? And no one died? https://en.wikipedia.org/wiki/Apollo_Guidance_Computer#PGNCS_trouble https://en.wikipedia.org/wiki/Apollo_Guidance_Computer#PGNCS... To be fair, I don't know to what degree J. Halcombe Laning's software was influenced by Hamilton. She's pictured next to the "software" section of the Apollo Guidance Computer Wikipedia article, but not mentioned. > The design principles developed for the AGC by MIT Instrumentation Laboratory, directed in late 1960s by Charles Draper, became foundational to software engineering—particularly for the design of more reliable systems that relied on asynchronous software, priority scheduling, testing, and human-in-the-loop decision capability.[14] When the design requirements for the AGC were defined, necessary software and programming techniques did not exist so it had to be designed from scratch. https://en.wikipedia.org/wiki/Apollo_Guidance_Computer#Software https://en.wikipedia.org/wiki/Apollo_Guidance_Computer#Softw... - - - - FWIW I suspect that these folks are going to be the coming cutting edge (of true software engineering): https://www.categoricaldata.net/ https://www.categoricaldata.net/ ... fallout from Applied Category Theory http://www.appliedcategorytheory.org/ http://www.appliedcategorytheory.org/