DTACK Grounded

Hal Hardenbegh has passed away (in June, actually).  Link.

Who?

Why, the author of the 80s newsletter DTACK Grounded.

What?

DTACK Grounded was the rant forum for the smart, driven and idiosyncratic Hal Hardenbergh, who was on a mission to create the fastest 68000 machines (and BASIC interpreter) on the planet.  (DTACK is the signal from the memory system to the 68000 indicating “Yup, you can complete that memory cycle now,” and simply stapling it to ground means you’ve built a system with as few memory waits as you can.  I recall the DTACK Grounded boards were insanely expensive because they used a metric boatload of static RAM, but they ran as fast as raped apes).

Hal’s newsletter was interesting not only because of his outre’ standards for performance, but also for his observations on the computing industry.  IIRC he hated Apple.  He somewhat liked the Atari ST, but was still critical of it.  He ranted against the x86 platform and was never short of advice for the industry.

My roommate and I always looked forward to the next issue of DTACK Grounded, and we were sad when Hal stopped publishing it.  We knew Hal was a lunatic, but he was a fun, expressive geek’s lunatic, and despite his obsession with making a fast BASIC interpreter, pretty dead-on with his pithy observations.

I don’t know if the newsletters are online anywhere, but if you can track ’em down, they’re worth a read.

Old, jealous gods

In the beginning was Big God Mainframe, cared for by a carefully selected and well trained priesthood that dusted The Machine, changed-out components on the ordained Master Schedule, protected The Machine from environmental harm, and very occasionally and begrudgingly let users run programs on it, after proper cleansing and supervision in the rituals of submission. And like many demanding gods, users brought offerings to the altar of Big God Mainframe so they could be executed.

—-

Luser at pick-up window: “B-but, my printout is totally mangled! How can I possibly turn in my assignment like this?”

Flunky Priest (2nd rank): “That’s pretty torn up, yup. You must’ve done something wrong. How many times did you genuflect before handing in the deck?”

“Three, like the T/A said. To the east.”

“Hmmmm, should have been sufficient. Candle?”

“I bought it at the concession down the hall. You sold it to me.”

“So I did. No problem there. Let’s see … the aura checks out, the planetary alignment is fine … ah, I see what went wrong.”

“What?”

“A bad printer escape code here, followed by a blasphemy, an undefined storage tag, and two mortal syntax errors in the BENEDICTION SECTION.”

“Oh. But what do I do?”

“Three mantras, a cone of incense next Knuthday, and fix the return statement right here. I’ll tell your T/A that the prior job was unsanctified and blew yours up, too. Sometimes God has lousy aim. That, or the power supply is about to fry again.”

“Gosh, thanks!”

—-

College computing: No fun at all in the 70s and early 80s… 🙂

We dinna take no simian ticks, nossir

Once upon a time I thought it would be “good for me” to learn denotational semantics. It looked like people were doing cool things with it, it looked like languages that leaned on it heavily (like ML) were worth learning, so I got a couple of books and started reading.

A couple books later I was still as confused as ever. And mad, too.

Even in an introductory text I got the sense that the authors were trying to make themselves look smart at their readers’ expense. A page into a new chapter and they’d whip out a completely new symbol (a crippled-looking M, or a Q doubled-over in agony), surround it with a constellation of superscripts and italic subscripts, then incant “… it is therefore obvious that…” and be off into the galactic void, sky-writing with half of the goddamn Greek and Egyptian alphabets.  I felt stuck in mud, dumb as a sack of bricks, and seriously doubting that giving the authors unsupervised access to TeX had been a good idea.

I can see myself in a course using that book as a text . . . well, no I can’t. I’d wind up in a corner muttering about wacko square-brackets with candy-striped uprights and the semantics of lambda-something-or-other under zeta-prime reduction.

I think my head is built wrong when it comes to mathematical notation. I see a gaggle of heiroglyphs in close formation and I have to think hard about operator precedence and how the particles in the statements need to be parsed, and in what order. Vanilla math, no problem. Calculus, I have to think about the ‘dx’ stuff. Denotational semantics, well, I nearly threw one book across the room when the author started using undefined operators from out of the blue; no definition, nothing to help me understand the particular rabbits on that page. Okay, professor, I hereby declare (goofy squiggle) to mean “my prof is a poopy head, x dx,” put that in your theorem prover and smoke it. But you’ll never figure out what (goofy squiggle) really means, because I won’t define it anywhere.  It seems only fair that way.

Is this how academic feuds start?

So I went back to writing tools and operating systems, an ignorant man, a person upon whom attempts at enlightenment had been squandered, but a happier one.

Good stuff

Enough ranting. I want to talk about code that I liked, and what I learned from it.

The first really good stuff I encountered — after a number of years of reading Byte and Dr. Dobbs — was the late 70’s “new wave” clique of Kernighan, Ritchie and Plauger. I inhaled K&R’s _The C Programming Language_ and soon after that, Kernighan and Plauger’s _Software Tools_ (the hair-on-your-chest RATFOR version). And, of course, John Lions’ commentary on Unix, pilfered in classic Lions’ Notes AT&T Trade Secret Violation Style at 8pm on the office xerox machine.

I’m convinced that early exposure to Pretty Good Stuff helped me out a lot in school. Most of the courses I took in college were like “Here’s an algorithm, go implement it,” without much exposure to exemplars of good style at all. I had the feeling that TA’s had to wade through ghastly piles of brick-like Pascal from other students, and that the TA’s rather liked the style of the projects I turned in.

The next Good Stuff I read was at Atari, and it was some of the best 6502 assembly language code I’ve ever seen. What this code did was control the coin mechanism on many of Atari’s arcade machines (Tempest and Battlezone at least). It handled a lot of security issues (I forget what kind of jiggering it was capable of detecting, but it was rather a lot) and many different variations of currency (including foreign denominations) and payment setup. And it had to get things correct, or a pissed-off user might smash the machine and burn it.

I read most of the source to Donald Knuth’s TeX. I have a love-hate relationship with literate programming. On the one hand I think it’s a neat way to present a program. But on the other, I’m just not into writing literature; most of the time I just need to bang out something that works pretty well and that won’t leave the next guy twisting in the breeze. Raising edifices of deathless prose is a lot of bloody hard work. We can’t all be Hemingway; some of us have to write about the local dog shows.

I don’t think I read anything at Apple that really captivated me; maybe the Newton kernel, or the NewtonScript interpreter. However, I did see another example of great low-level code; a number of departments had huge feet-long bound listings of the Macintosh ROMs, which were very well commented 68000 and 68020 assembly. Many lines of it had the initials of the engineers who had last touched them, and you could tell at a glance where the hot spots were. (Updates to the 68K-based Macintoshes were pretty horrendous, and we carried this tradition along to the Newton — basically, you’d hook parts of the system and insert logic, by hook or by crook, that fixed problems or added features. Where you couldn’t directly patch something you could usually arrange to redirect a return address somewhere above you or something. There were some world class clever programmers at Apple who could take someone else’s attempt at a patch — say, fifty bytes — and boil it down to a gnarly twelve byte knot of distilled evil genius. It’s wonderful to have people like that guarding your back on a project).

There’s a style of systems programming that I aspire to that might be described as “just enough to carry the story” — it’s like that very spare 70’s Unix style, but with a little more plot. As a young programmer I tended to put hooks and cute features into everything; stuff had to be full of bells and whistles and show-off a lot or it wasn’t fun to write. These days I try to do just what’s necessary in the most direct and clutter-free way than I can think of. Usually this takes a couple of passes; often it involves ripping junk out, and it always involves checking my ego at the door. I am nowhere near the level of some masters of the art that I work with, and I hope to grow up to be like them some day.

Sometimes I ask people that I’m interviewing, “What’s the most interesting code you’ve read?” It’s saddening how many people don’t even understand the question, like I’m asking a ditch-digger which shovel is his favorite. Occasionally, though, a light will come on in the other person’s eyes, and they’ll start talking about the really neat garbage collector they ran into a while ago, or the Mark XIV shovel with the tempered rivets, scalloped handle and semi-gloss finish. And you know you have met someone who enjoys seeing quality software, studies it, and maybe knows how to write it, too.

Little boy lexicon

“Aunt Juice. Not a relative, but as in, “I want juice.”

“Uh! Ah!” (points) I want something out of reach that I’m too lazy to tell you exactly what it is, and also it’s entertaining seeing you struggle with the whole guessing game.

“No!” “Yes.” As in, “Do you have to pee?” when he is at the hunched-over-and-dancing stage, ready to hose down whatever he’s hopping near and facing toward. No, he doesn’t have to pee, because that would admit weakness.

“Yes.” “Hell yes. Right now, dammit, and be quick about it you fool, what is taking so long?”

“What is that?” Because I want some.

“Is that [X]?” Because I want some.

“Daddy, I want to show you something.” refrain: Because…

Who’da thunk’a dat?

On optimizing Linux boots: “The X Window System runs the C preprocessor and compiler on startup, in order to build its keyboard mappings.”

And that [gulp … hrullphh] is all you need to know about X [grwawwwlphh!].

Link.

Later in the article: “X is still problematic. ‘We had to do a lot of damage to X…’ ”

I mean, how could they tell?

[Edit: diked-out compiler reference, based on comments.]

Buried again

Apologies for lack of posting.  I’m buried at work, and must also keep the yard from turning yet again into jungle.  Additionally, having little to grip about besides politics (which I am miserable at), I’d rather just hole up with a good book.

Here’s a nice article on the file structure of MP3.  Really well written.  Link.

Finished _Anathem_ (verdict: Very good.  I’m going to read it again soon).

For entertaining-and-not-challenging reading: Leo Frankowski’s Crosstime Engineer series.