Hacker News Reader

Comment by xiaoma | Hacker News Reader

>While no one programming legend can possibly accomplish any big feat solo, there are programmers worthy of fame for their supreme productivity.

Actually at least one programming legend did according to many:

------

Woz designed all the hardware and all the circuit boards and all the software that went into the Apple II, while the other Steve spewed marketing talk at potential investors and customers on the phone. Every piece and bit and byte of that computer was done by Woz, and not one bug has ever been found, “not one bug in the hardware, not one bug in the software.”[15] The circuit design of the Apple II is widely considered to be astonishingly beautiful, as close to perfection as one can get in engineering. Woz did both hardware and software. Woz created a programming language in machine code. Woz is hardcore.

-Geek Sublime: The Beauty of Code, the Code of Beauty

View on HN

"Woz prototyped the guts of the Apple II, but needed a lot of help from people like Fernandez to turn it into reliable, repeatable hardware":

https://www.reddit.com/r/business/comments/3jyovw/woz_jobs_d...

Also, how about:

- Donald Knuth (TeX, METAFONT); even more surprising here given that he's mentioned in the article a few times on other accounts; https://en.wikipedia.org/wiki/Donald_Knuth

- Fabrice Bellard (QEMU, FFmpeg, & other) https://en.wikipedia.org/wiki/Fabrice_Bellard

Good examples.

Right. You saved me from making this outstanding correction.

So, Knuth did TeX, METAFONT, Web, Weave, and Tangle for literate programming, and published the literate version of the code. Essentially just one guy.

Or Bill Joy: vi, c shell and large parts of BSD.

Knuth had help from his graduate students. Some of them did their dissertations on work they did in TeX and I think METAFONT too.

hmm; "[citation needed]", although I've already found something via Wikipedia:

https://gcc.gnu.org/ml/java/1999-q2/msg00419.html

"[...] Knuth definitely wrote most of the code himself, at least for the Metafont re-write, for which I have pesonal knowledge. However, some of his students (such as Michael Plass and John Hobby) did work on the algorithms used in TeX and Metafont. He also did have a programmer (David something) working for him at one point, but not as I recall at the time of the Metafont re-write."

That said, some solid source on the earliest phases, as well as on particulars of the specific "algorithms", would be nice to learn.

I intended to prove that wrong one day given what I've seen Moore, Wirth, LISP machine people, etc do with no more than two people. However, if I'm to be honest, anything I come up with individually will be a rehash of what a bunch of others came up with. So, hard to even say it was my own work unless I did something radically different across the board from the circuits up.

The Lisp Machine project had way more than 2 people, and something more than 2 full time equivalents.

Possible. I just saw Steel Jr and Sussman's names. Then implied a LISP machine could be made with 1 person if it could be made with 2. Just take more time. So, if not that one, than any that was only done with 2 people.

Errr, to my knowledge, neither of them made major contributions to the Lisp Machine, outside of perhaps ideas.

It sounds like you're referring to their Scheme chip project, which they did not have the resources to push to success, e.g. getting the microcode right in one or two tries (the computing resources to simulate it were not available).

The Lisp Machine proper was a project done with TTL and fathered by Richard Greenblatt, who probably did some hardware design and more likely microcode work, as well as system software as I recall. However the principle hardware designer was Tom Knight, David Moon wrote a lot of microcode (the Lisp Machine's microcode did a lot, e.g. eval, GC, the bytecode interpreter), he and Dan Weinreb are the only authors listed on the cover of the 1981 4th edition of the manual, Weinreb wrote the first text editor for it, the per Wikipedia and my faint memory the 2nd EMACS implementation, and the first with a GUI and done in Lisp. Howard Cannon developed the Flavors OO extension, with which I remember a lot of the GUI was implemented.

It was a pretty big project; hmmm, TempleOS is the only "comprehensive" OS I can think of that was done by one or two people.

Yeah, it was the Scheme chip I was talking about. I guessed that they were included in the banner of LISP machines because Scheme is a LISP. So, they never actually built it? That's disappointing.

No, they built it, but the microcode had enough bugs it wasn't viable as more than a proof of concept, and it was also a part of the brand new and very exciting Mead & Conway revolution (https://en.wikipedia.org/wiki/Mead_%26_Conway_revolution).

After that the MIT Scheme community concentrated on producing a good version of the language for the 68000, which of course developed an ecosystem a homegrown chip could never hope to achieve back then. This was to support Sussman's work, including SICP/6.001 (Steele went to CMU "to bring the light to the heathen" :-).

Ah, thanks for the Mead & Conway revolution link. That fills a gap in the hardware and EDA research I've been doing: the how of the transition from discrete to custom chips. So, they practically invented VLSI methodology and MOSIS service? That's pretty awesome.

Back to Scheme. Ok, so they built it but it was a buggy, throw-away, proof-of-concept. I'll try to remember that in future references. Then they transitioned to software and SICP. Ok, a working Scheme chip would've been neat for me but I concede they made the right call for the time. Plus, it's better to work out a concept and how it will be used before trying to put it into silicon. Lets you decide which parts are really worth putting in hardware.

"Steele went to CMU "to bring the light to the heathen"

Haha. That's funny. Guess that's my job now. Appreciate your clarifications on the Scheme chip and its context.

not one bug? lets be real.

Wow, thank you for that quote. That boggles my mind. Not one bug? I've seen impressive programmers in my life but never like this.

Look at Wirth's and Gutknecht's Lilith project. After seeing Xerox's PC's, they independently from Apple invented a PC and GUI line involving: a custom computer; a CPU from bit-slice chip; an ideal assembler (M-code); a high-level, safer language (Modula-2) built for it; compiler; primitive OS; basic tools. This work and much of its methodology later became the Oberon language and system, also a 2 person job. They also implemented custom HDL's and hardware for it later on. I believe one person, esp of Wirth's or Gutknecht's capacity, could've built all this albeit with a lot more time required. The key was simplicity, layers, understanding each module, and incrementally building them.

Lilith System http://www.cfbsoftware.com/modula2/Lilith.pdf

Oberon System http://e-collection.library.ethz.ch/eserv/eth:3180/eth-3180-...

Synthesis of Hardware Circuits from Sequential Programs http://inf.ethz.ch/personal/wirth/Oberon/286.pdf

The processors http://oberoncore.ru/_media/library/computersystemdesign.pdf

People like them are the true "full-stack" developers. Apps, OS, circuits... coded it all and integrated it cleanly usually in 2 year periods.

One interesting aspect of Wirth's work, which is illustrated by Oberon, is that he always iterated — from Pascal (itself heavily influenced by ALGOL) to Modula, to Modula-2, to Oberon, then finally Oberon 02. Apple's ObjectPascal is in there somewhere. For example, as I understand it, Oberon was basically bootstrapped with Modula-2.

They're all Pascal-like, and therefore ALGOL-like, sharing a lot of similarities; not just syntax, but also concepts such as ranged types, range-bound arrays, enums, record syntax, etc. You can know Pascal and be able to pick up Modula or Oberon very quickly, since so many keywords and concepts are identical. At the same time, each iteration tried to simplify the language (the BNF for Oberon has only 33 grammar rules).

That's a good point. A strength of his improvements in terms of learning curve and re-using prior work. He was always good at that part. However, I like best how he designed the assembly languages (P-code, M-code) and high-level languages (Pascal, Modula-2) to be consistent with one another. Some called it a hack but I think it's brilliant. Imagine how easy it would be to learn inline assembler if its workings matched the language behavior already described to you. It's like explaining stacks, frames, goto and math in C was about all it took to know x86 programming. It would make both ends more effective.

He did it for ease of implementation and compilation. Still need that for formal verification of whole systems, securing whole systems, people that like to experiment with them, and so on. So, his principle stands the test of time.

Reply on news.ycombinator.com