Today I want to talk about another vintage book — this one from 1985, eleven years after Kernighan and Pike’s Elements of Programing Style came out. While EoPS is largely timeless, this one has aged dramatically; but it was so important to me twenty-something years ago, and embodies an era that I remember with such fondness, that couldn’t resist writing about it.
R. C. West was a bit of a legend in the Commodore community of way-back-when, along with Jim Butterfield and others whose names I no longer recall. Their work would appear in magazines and newsletters, often in the form of programs that you would type in — not games or business applications, but utilities like faster tape drivers, routines to renumber your BASIC programs or disassemblers for machine code.
When Programming the Commodore 64 came out, there was no question of not buying it. It was a non-negotiable necessity, because the subtitle — The Definitive Guide — was spot on. “Definitive” was the word. It’s hard to believe these days, but in 611 pages, West wrote down everything there was to know about the C64, from hardware and firmware, via the BASIC dialect, through machine-code programming, graphics, sound, the layout of the ROMs, programming the disk drive, and much, much more. If you don’t believe all that could fit in a single book, and that only two-thirds the size of a modern XSLT tome, check out this scan of part of the contents listing:
(You’ll probably need to click through to make out the gritty details.)
Now I know that there is already plenty of old-fart nostalgia on this blog — a lot of people have interpreted Whatever happened to programming? as a yearning for the days when you had to do everything from first principles, which wasn’t really what I meant. But I do, I really do, miss the days when it was possible to understand the whole computer.
I’m not claiming that I ever had the level of mastery that people like West and Butterfield had. I was never really a big machine-code programmer, for one thing — I wrote routines to be called from BASIC, but no complete programs in 6502/6510. And I’ve never been a hardware hacker at more than the most trivial swap-the-video-cards level. But I did have a huge amount of Commodore 64 lore internalised. I knew which memory location always held the scan-code of the key that was pressed at that time; and where the screen memory-map began; and which locations to POKE to play different pitches on the various channels of sound, or to change the screen or border colours. I knew hundreds or thousands of those little bits of information, as well as being completely familiar with the horrible BASIC dialect that was in one of the ROMs. In short, I knew the machine in a way that I don’t even begin to hope to know any of my computers today; in a way that, I am guessing, no-one anywhere in the world knows their machines.
I miss that.
And thanks to R. C. West, if I found I needed to know something that I hadn’t already internalised — say, the locations of the BASIC warm start vector and the tape interrupt vector — I knew where I could look them up:
So I think this is part of what I was bemoaning in Whatever happened …: the loss of the total control that we had over our computers back when they were small enough that everything you needed to know would fit inside your head. It’s left me with a taste for grokking systems deeply and intimately, and that tendency is probably not a good fit for most modern programming, where you really don’t have time to go in and learn, say, Hibernate or Rails in detail: you just have to have the knack of skimming through a tutorial or two and picking up enough to get the current job done, more or less. I don’t mean to denigrate that: it’s an important and valuable skill. But it’s not one that moves my soul as Deep Knowing does.
I’m not sure how I feel about that. One of the reasons I recently learned Ruby is that there’s a web-site I want to build, I’m sick of hacking Perl’s HTML::Mason templates and repeatedly re-implementing half of an ORM, and Rails seems like a very well regarded technology for that kind of thing. It seems that most people who want to learn Rails plough in with one of the tutorial videos and start hacking, but that doesn’t satisfy me: deep in my soul, I need to know Rails before I’ll be happy building things with it. And I truly don’t know whether that means it will take me a longer or a shorter time to get the site running to my satisfaction.
(Happily, it’s my birthday today — I’m 42! — and my wife gave me Agile Web Development with Rails. So hopefully it will all start to sink in soon and I’ll be ready to start Doing Stuff in a month or so. I’ll let you know how it goes.)
Even so, something has been lost when my Deep Knowing aspirations have been reduced to learning a mere web-app framework rather than, as in the 80s, learning a whole computer.
On the other hand, I do not miss typing in machine-code programs by hand from long listings in books. Whenever I get too misty-eyed for the old days, I remind myself about this kind of thing:
So maybe what we’ve lost on the swings, we’ve gained on the roundabouts.
Still, it was great that, for a decade or so, it was possible for an ordinary layman such as myself to buy, read and learn books that would make you the absolute master of your computer. In that respect, at least, it truly was a golden era. So, R. C. West, we salute you!
Update (14 March 2010)
Coverage of this article elsewhere on the net:
And more importantly, you can download a PDF of the book from DLH’s Commodore Archive at http://www.bombjack.org/commodore/
The Reinvigorated Programmer 
Looks like a great book. I only ever had the “bible” myself, which was supposedly the most complete reference, though I found it to be lacking at some points.
It’s a amazing that people still love and stick with the C64 even today, and how they’ve found and learnt to exploit every little intricate and unintented feature in its chips (find “Edge of Disgrace” on YouTube to see what I mean).
And I could never understand why publishers of these BASIC loaders for machine code programs did stick with those huge integer data statements. A better way would be to use character strings of base 64 encoded data, along with a checksum for each line.
Happy birthday!
I’m 20, so I can’t remember the days when one *could* understand the whole computer. But I know what you mean. I look back at the simplicity of systems like Version 6 (I’m a Unix geek) and wonder where we went wrong.
I was an Atari developer back in the day. The book that I fondly remember was “Your Atari Computer” (http://snurl.com/ut7ry). A great title that fully documented the machine and Atari BASIC. Another great book from that classic era, if you can find it, is the original “Programmers at Work” (http://snurl.com/ut7t3). I have a vintage copy on my bookshelf.
Have you played around with one of those Arduinos (or Stamps)? They’re big with robotics fans, since they have analog input and output pins you can hook up Radio Shack type stuff. You can actually understand them from top to bottom. They are usually programmed in a subset of C, but the machine code is accessible.
I sort of miss the top to bottom knowledge one used to require to get anything done. The IBM 1130 and the Interdata machines were my top to bottom babies. One the other hand, it is nice NOT to have to worry about disk drivers, files systems, preemptive schedulers, I/O libraries, format converters, parsers, assemblers and the greater and lesser arcana.
Instead, I rely on a certain urban literacy that lets me navigate obscure interfaces and understand a broad variety of API documents. Do I really want to write another JPEG compression algorithm? Once was enough. Really. The top to bottom knowledge was very Robinson Crusoe or Mysterious Island, building 17th (or 19th) century society and industry from scratch on a desert isle. Now the isle is just one in an urban archipelago connected by a high speed train, but I know how the ticket vending machine works and which trains make which stops.
“But I do, I really do, miss the days when it was possible to understand the whole computer.”
Man, this hits home with me. I just yesterday looked at my old code on my C64 and it was completely indecipherable, I’d forgotten so much. I don’t know how I had managed to achieve it at the time, but basically you had to remember everything about the C64 and every line of every program you wrote (so to know what GOSUB to call to do what). It wasn’t a good way of programming, I wouldn’t admit that, because now it’ll be almost impossible for me to understand these programmes again unless I write them out on paper or PC and comment them (and even then, that won’t tell me what POKE647,0 does). But it did mean that you could understand the _whole_ of the machine, everything. It is possible to know every last thing about the Commodore 64, and therefore have complete mastery over it.
Nowadays, I’m just a meta hacker. I write interpreted code on top of one API that sits on top of another API and it’s turtles all the way down until you get to the hardware, which I don’t understand either.
If the Commodore64 had a better programming language, and certainly a better programme editor (with something as advanced as a search function!) then I think it’d be a lot more accessible. Right now, I don’t think it’s going to be possible to get back into it, but I would like to have a crack at skipping basic and going pure machine code.
Speaking of books, I have some very rare books that I started out with and picked up at car boot sales along the way like Pan Computing’s The Companion to the Commodore 64 (it was fun to read the author’s musings on the future of computers) and Advanced Machine Language for the Commodore 64.
Pingback: Programming the Commodore 64: the Definitive Guide | JetLib News
Should anyone wish to read this book an electronic copy can be found in the Books section of the following website:
http://www.bombjack.org/commodore/
Ah, memories. I wrote some C64 books myself, on graphics/sound/assembly language, way back when, and it was a labor of love and fun. I’m always amazed that there are folks who still use them today.
This brings back lots of memories. I miss banging the hardware. It’s purely amazing what an 8bit 1mhz computer can do with the right code. Those were the days when coding required creativity. Trying to make things work in a few kilobytes of ram was a challenge.
> POKE647,0
Heh, I still remember POKE 23609, 255 (I had ZX Spectrum) for beep …
The notion of deep knowing is one of the reasons I have so much fun playing with microcontrollers and electronics; I get to make the computer. Granted, I start with someone else’s processor, but those can be completely understood. The 8-bit PICs are easiest, but even 32-bit microcontrollers are easier than modern PC processors. Then I get to add hardware to complete a system that I know inside and out. I’ve been meaning to start on another project like this sometime soon.
Wow, I also celebrated a birthday yesterday, I also turned 42 (March 12 Pisces people rock!!!), anyhow hate to be off topic, hope you had a good birthday too… :)
—
/phil
I spent every free moment hacking assembler on the c64 back in the day. I knew every register and every little bug. Those days will never come back. I miss it …
if you want to do some web development and still retain the requirement for ‘deep knowledge’ , you might be interested in my netboot65 project (http://netboot65.sourceforge.net/ ) – there is an web application server API in there for the C64 (with an ethernet card) that uses templates that are a mix of html + machine code, although the docs are still way too terse.
Check out Hans Peter Messmer’s “The Indespensible PC Hardware Book”. The edition I had is a bit dated but it seems there are newer editions available. A really interesting book.
And it was eminently hackable. I remember an article in some Commodore magazine (Transactor, I think) about a guy who put in a custom PROM to replace the BASIC, and turned the C64 into a sophisticated heating control system.
And then there was GEOS, which completely took over the system for its own purposes.
I didn’t do anything so esoteric. I just did 1MHz audio sampling on voice 3. (Yes, I found a way to do that on a system with a 1MHz clock…) I also put a password lock on my GEOS disk. Just because I could.
Crawford’s “De Re Atari” is still a better book about a better computer! ATARI FTW!!!!
I still have my complete C=128 system, JiffyDOS, 1541-II, 1571, 2 1581, 512k REU, mouse, dual display monitor, DataSette, CMD high speed modem interface (14.4k modem? Of course!) the dozen or so manuals and guides, and of course, a box full of utility cartridges.
There was nothing I could not make that 128 do within the very elastic limits of the hardware and software.
It’s all safely packed away, waiting until I have a somewhat larger apartment and then it will be resurrected. And if the Ethernet User Port interface is still available, the 128 will be online along with the two Macs.
You’re right. The C=64/C=128 were among the last computers you could KNOW from top to bottom/inside out.
You’ve tempted to pull the SX-64 out of the closet and see how much I remember.
As a kid, I cut my teeth on Atari 8 bit computers and also came away from the experience with an enduring appreciation for what you call “deep knowing”. Programming has become a different game with these massive, ad hoc systems. But, I’ve ended up going into a more research track, where there’s a similar relationship to your work: the (mathematical) systems are, in some sense, simple enough that any change to them has consequences that can be completely characterized. I usually had thought that the fact I ended up working on what I work on had little to do with my hobby programmer days, but this post makes me think the experience shaped my tastes in some way.
If you want something to really dig into, try a device driver. It’s actually quite refreshing to fool with that kind of low level madness on a modern os.
It is true. So many programmers today write code and don’t really have any idea how the computer really works underneath it all. Back in the 1980’s it was impossible to write much of anything complex without understanding how the computer works.
I did a bunch of code on the c64 back in the 80’s. Since I was developing on the machine itself (no money), I found an added reset switch invaluable :) Would use turbo assembler, assemble, run code, reset then sys 36864 to get back to the editor (with hopefully a still intact file). ahhh.
Not the best way to work.
Anyway, as the first comment mentioned, do check out ‘edge of disgrace’. Run it in VICE if you have to. Good show and great SID music. The SID has so much soul.
It’s been since 1984, but I still remember every address from $0000 to $FFFF (not to forget the mirror ROM banks $A0000-$C000 and $D000-$FFFF) fondly.
From POKE 646,128 to SYS 64738.
Hi!
I’m right there with you! Taking a whole afternoon out of the warm, sunny weather to type in an endless number of numbers while a friend dictated to me.
I remember using Micromon: “SYS 41952”. Like you, I never did significant machine language coding, but I was able to hack one game to give me more than 3 lives and change the entry address for Micromon to several difference addresses (“SYS 8192”).
Games were a big seller for me… A friend had “connections.” He’d always have a new handful of 5-1/4″ floppies (double-sided using a hole-punch) with new games every week. The weekends would be spent copying using one or two programs (the names escape me at this moment) able to bypass the “security features” that existed at the time.
Thanks for allowing the memories to flow,
Michael.
Thank you! I’m not alone! I was born in 1965, got a TRS-80 in Grade 9, and learned TRS-80 BASIC and then Z-80 assembly in short order. Then in my high school, which had several Apple ][+s and one Atari 800 (loved Star Raiders), I learned 6502 assembly. Ah those were the days. Thanks for making me reminisce. I’m glad I’m not the only one who values the days of knowing the whole machine.
poke 53281,5
Jsr ffd2
Pingback: Cubicle Hermit » Commodore Nostalgia
This is what I’m talking about. Total control and the ability to understand everything that was going on. The amazing thing was that I could take other people’s code and learn from the assembly within.
Back in high school, one of the simple things I remember doing in assembly because BASIC was too slow was that for a school project, I wanted some letters scrolling along the the screen and use that on a VHS tape for the end credits to be displayed during the presentation. I created some sprites shaped like the letters I needed (with color) and wrote an assembly program that would scroll those sprites. Hooked it up to the VCR and presto, end credits! I did a few funky things with how the sprites appeared and moved around. People in the classroom were more interested in how I did those effects than anything else.
Fun times. Later on, the Amiga became popular for doing subtitles.
Great Article! I’m 42 also, and I also don’t miss typing in page after page of code, excitedly, as if waiting for that prize at the bottom of the cracker jack box when I finally ran it (after also correcting my typos, or theirs) . In any case, I loved the foundation that stuff gave me, and I did in fact feel much more connected and ‘in command’ of the computer on a deeper level. Now I learn the pieces I need to ‘get the job done’ as well, but I really miss that element of the comfort-level that knowing this stuff on a deeper level provided. Thanks for the walk down memory lane, I really enjoyed the write-up.
I’m 47 and I can completely understand where you are coming from. I remember being able to pretty much understand the IBM PC from the inside-out, or when the Windows API fit in two binders. I’m guessing knowing the C64 inside-out was probably more interesting, but I can understand.
Oh, this reminds me of one other thing. I have some old C-based utility kit books in my collection, all of which are long out of print. One of them was by Jack Purdum (one of the authors of the Ecosoft C compiler) and it had, among other things, a complete B-Tree-based database system for C. I remember buying the book and devouring the details on how this worked.
It seems like these kind of books are no longer produced. Yes, you can go get the code to MySQL or SQLite or Postgres, but it was nice having something that you could possibly comprehend completely.
Ah, memories. I still have my beaten-up copy of Raeto West’s Programming The PET/CBM, which was similarly excellent. I went googling for the author not long ago, and was shocked to find that he clearly went off his meds, because from one of the great hardware/software documenters of the 1980s he devolved into a weird conspiracy nut, ranting in multiple font colours about fluoride in the water and some kind of Jewish conspiracy and everything in between. And he disappeared, so I hope he got the help he needed but I fear he probably fell prey to his demons. A sad end for a man whose books changed my life.
Heh. Reminds me of my days (I’m just two years older than you) poring over the various “Cheat sheets” for the Apple II. Call -151, anyone?
Nonetheless, this is just what we have to get used to. There was a time when not just deep knowledge of a computer, but the sum of all human knowledge, could fit into the brain of a reasonably intelligent person. We have the much better world we have today because those intelligent people created more knowledge than any one of them could know.
I honestly do not miss the days of writing, say, event loops to figure out which button on the interface someone clicked, or, just as bad, hand-coding the pixel positions of those buttons and running the program to see if they looked good, lather, rinse, repeat. True, doing that work probably made me a better programmer. But I want to create interesting and useful programs to do tasks, not to create interesting and useful programs, and even though there’s plenty of low-level and mid-level code I *could* write myself, I’d much rather see if someone else has done it and I can just include it. Every hour I don’t spend writing code to, say, parse and read a CSV file is an hour I can spend writing code that does something unique and interesting with the contents of that file.
jsr ffd2 — hehe
M. Terry A. Davis – you stolen my punch!
I had the C64 for 2 years and I wrote from the very beginning scratch ( okay using the native C64 Basic to start it up ) a complete assembler (even better than that one embedded into the C128), and at the end, no Basic code helper at all… It was amazing, useless, useless, useless… but extremely COOL to do!
I am old .;( oh my! I’m getting old!
Those were the days ;)
Got my 64 on I believe it was Oct 16th 1981, after spending most of my afternoons for 1 1/2 years in the computer department of a department store, hacking on a Spectrum … and was disappointed how primitive the Basic was …
Moved on to 6510 assembler pretty quickly, which on the 64 was the only programming of choice available (and usable) … after moving on to the Amiga 1000 in 86, I re-used my 64 as a debugging terminal some time later (hacked the A1000 kickstart to use the parallel port instead of RS232 for the ROMWACK, and hacked a 80 char display routine for the 64 :) )
Even with the added complexity of the Amiga, you could still know most of the system, with the help of a couple of books … commented ROM listings were still feasible …
Nowadays, we have it a lot better – we have the commented source code :) Well, at least those running Linux do ;)
For my low-level-needs, I do some AVR hacking every now and then (e.g. complete Quartermile drag racing timing system and tree, working on a Geocaching puzzle cache using AVR), or go back to 64 via emulators to create some tough (though for 64 hackers extremely simple) geocache mysteries … ;)
@Terry: That won’t work, you mixed Basic with Assembler … also, you’ll have to LDA the char you want to output first … setting the foreground color alone won’t help ;)
Happy Birthday! I still have a book “Programming the VIC-20” ;)
Man! This takes me back! I’m 44 yrs old and remember when I was 16 and was “playing” on my Commodore Vic 20 (the predecessor to the Commodore 64! It had a whole 5K of RAM!)
I remember those DATA statements in BASIC that were published in various magazines like Compute!
But what I REALLY miss is that when you turned one of those machines on, the machine came on and was READY to go in like 2 seconds. Now, my Windows XP system can take as long as 5-10 minutes before it has everything completely loaded and even Kubuntu Linux can take 30-45 seconds. It makes me wonder why we call this “progress”!
Just remembering those long lists of basic code that we used to type in our computers from magazines or books hoping to see just a simple game, how many times the power failed just before we finish, back in the times of no UPS, hehe.
The book I remember most (besides Compute! Gazette) was the ‘Commodore 64 Programmer’s Reference Guide”. Made by the manufacturer… Also there was compute’s “MLX” to type in programs… load “*”,8,1 — -fastload cartridge, “fast hack’em” disk copier… oh, the good old days. And of course, toy bizarre, ms pac man, and the “Welcome! Stay a while… Stay forever” — don’t remember the name. poke 54280,0 : poke 54281,0 : and so on. programs that load at $c000 aka 49152 ; the keyboard buffer #198; the ram under rom at 32768… man were those the days…..
Imagine a modern day computer (maybe with a RISC processor) that had a very simple ROM based bare bones OS with a sturdy embedded C compiler. Instant on. Sprinkle in an integrated sound and a graphics co-processor. No hard drive, just a few gigs of RAM and 100 gigs of solid state non-volatile memory to store programs. USB peripheral I/O. And everything totally documented like the Commodore machines of old. Something like a C64 on steroids.
Code directly to the metal on a modern CPU. Like you were on a PDP-11. But grease lightening fast.
Now what would be cool.
Ahh…memories. I had this book, and remember typing in that ‘Supermon’ assembly coding tool, then going back, and checking every line to make sure it was correct. However, once done, It enabled me to create sprite interupts, and other stuff that was far too slow to be written in basic. I still have the book up the attic somewhere….must resist the temptation to get it out again…..
I, too, had a C64 (and then a C128), A year into them I found the cost of books and other references (not to mention time spent at minimum wage) far exceeding the purchase price of the hardware.
However, ‘absolute master of your computer’ is going just a bit too far. The controversial (users were divided on whether the reported bug existed or not, experts also disagreed) save-with-replace bug, was finally reproducibly demonstrated to exist in late 1985, and only then explained.
See:
http://www.atarimagazines.com/compute/issue65/save_with_replace.php
That said, what I learned from the C64/C128 was more relevant to completing my compsci degree, than most of what came after.
Eric TF Bat, if the Raeto West that you found is the same one who wrote these books, then this is a sad discovery indeed. I just googled the name and what I’m mostly finding is references to a BNP member, who I really hope is not the same guy. (For non-Brits: the BNP is a British National Party, an unashamedly racist political movement that is gaining a disturbing amount of influence in some area of the UK.)
Lizard made an interesting observation: “There was a time when not just deep knowledge of a computer, but the sum of all human knowledge, could fit into the brain of a reasonably intelligent person. We have the much better world we have today because those intelligent people created more knowledge than any one of them could know.”
And, yes, part of me wishes I could have lived back in those days (although a much bigger part of me is glad to be alive now, not least because we have computers … and blogs!)
I’ve known of, but not read, a book about the American palaeontologist (among many other specialisms), Joseph Leidy, entitled “The Last Man Who Knew Everything”. I just went and looked for it on Amazon, only to find that there are at least THREE books with that title (the other two being about Thomas Young and Athanasius Kircher). It’s evidently a notion that strikes a chord in more people than just me.
Gary wrote: “Got my 64 on I believe it was Oct 16th 1981”. I don’t think that can be right — according to the Wikipedia article, it wasn’t introduced until January 1982, with volume production starting in spring that year. (Amazingly, it had still not been discontinued when Commodore folded in 1994, although it was slated to be killed in the following year.)
L Chapman III: I think the game you’re thinking of was “Mission Impossible”, which opened with a stereotypical deep bad-guy voice intoning “Another visitor! Stay a while … Stay FOREVER!”
:-)
It was a good game, too. I played that one quite a bit.
I’ll just leave this here…
http://www2.b3ta.com/heyhey16k/
Mike, you’re right, I thought I was 13 when I got my 64, but I guess it was rather 1983, so I was 15 … oh well … quite some time ago ;)
Happy Birthday!
I was 15 when I got my C64 and I did a lot of programming in assembler on this machine. I wrote my own extended basic, disk and tape turbo utilities and hacked around getting sprites on the border etc.. It gave me the confidence to twiddle registers and optimise code. It led me to a career which ended me up as a kernel engineer working on Ubuntu! :-)
If pining for Deep Knowledge, use Linux! Specifically, a “geek” distro Slackware. (Debian has gotten too automated. OpenBSD or NetBSD would also be good choices.
My first computer was a commodore 64 SX (the portable one with a 5″ monitor)
I too have a desire to have deep knowledge of a computer and the programming language I might be using. This deep knowledge has a irreplaceable value in that you know what is suppose to work and when it doesn’t you have a much better idea as to why or what to look for or check.
But the growing complexity of computers and programming languages makes that more difficult with the approach we use or how we map and access the knowledge.
There is a way to deal with this, such that we can get back to having at least an accessible map of the knowledge, be it hardware or software, in a consistent, logical and usable manner.
See the web link at my name.
BTW, 42… isn’t that the answer to everything?
I got my commodore 64 1992. Then most of the books were hard to get and I didnt get longer than programming in Basic. But those were the days indeed, 13 years old and playing games and programming on the c64. Watching intros to games had you amazed. I miss those days too and wished I also would have had that book.
Ok, I found it at: http://www.bombjack.org/commodore/books/pdf/Compute%27s_Programming_the_Commodore_64_The_Definitive_Guide.pdf
:)
Oh Man….
BTW, 43, March 2nd. Happy To You as Well!
God, I remember soaking in the Tub in my first apartment reading a library book about game programming for the c-64. I kept checking it out until they made me return it. When I first Grokked the kernel and how to access the stack was probably when I crossed the line between Nerd to Geek, and it certainly shaped the rest of my professional life, even if I wasn’t programming. Shortly after that I ran a BBS (pre internet-internet, for you young’uns). Thanks for the Blast from the Past. And thanks Kaelberg for the Arduino tip. That is a great modern day equivalent to the old 6502, and is probably the C-64 of today.
Can’t recall the name, and I am on dialup, so I am not going to look it up ;)
I remember a frantic call from my sister one evening as she had lost her husbands grad school paper due to disk corruption. I spent the evening reconnecting the blocks on the disk so that the paper could be retrieved. What a great little box the C64 was. I learned Pascal, C and Assembly on it.
I very much share your feelings about the feeling of Deep Knowing that comes with full understanding of the machine. One of the most pleasant and enlightening parts of the introductory EE curriculum in my college is building a microprocessor from the ground up, and following up with all the required facilities to make it programmable and usable. It’s truly an eye opener.
By the way, given your earlier reviews in this series, I believe you would rather enjoy these two books: Leo Brodie’s Thinking Forth (freely available through the excellent volunteer work at http://thinking-forth.sourceforge.net/) and Biancuzzi and Warden’s Masterminds of Programming (O’Reilly).
Happy pi day! (:
I think you guys are being retarded. I had an Amiga, but just because it’s gone doesn’t make me “know any less” about my computer I’m on right now running Windows 7…. I know probably 99% of what’s going on inside my tower down to the hardware and software levels…. I might not have specific memory addresses memorized or specific resistor voltages, but trying to remember that stuff is overkill and doesn’t belong in my memory mappings. That’s what the internet is for.
That blog (and the very nostalgic one about growing up Commodore!) really resonates (I even got to work for C= in the Amiga days…oh, what a highlight!). Thanks for the great blog entries!
Great article. Not to rain on your parade, but are you infringing on copyrights by posting those images? Surely DLH is by posting the entire PDF. A book does not lose its copyrights when it goes out-of-print.
Friend McCarthy, so far as I can determine, the publisher no longer exists. There is certainly no-one is losing out by my publishing these scans, anyway (not indeed by DLH posting the PDF of the whole book).
@Mike Taylor, even though the publisher no longer exists, the writer or their estate might well (and probably do) retain the copyright.
Well, just as soon as R. C. West asks me to take the scans down, I’ll do it.
I’ll not be holding my breath.
@Mike Taylor: as a published author for Wrox Press, I would personally be pleased to see someone write an article about my work 30 years henceforth. I hope R.C. West (or his estate or the company which purchased the copyrights from the original publisher) feels similarly. My guess is they do :)
From “The Definitive Guide”:
“It’s often most efficient to have a friend call out the numbers as you type in the programs.”
Awesome advice, but I have a feeling that if I had a friend to call the numbers, I wouldn’t have been a lonely geek typing code out of a book in the first place!
I was 11 when I bought “Master Memory Map for the Commodore 64” by Paul Pavelko and Tim Kelly at a computer fair. It was (is) one of the most influential books I’ve ever read. It had wonderful illustrations and although a lot of it was beyond me, it really helped me understand a lot of computing concepts I’d struggled with and what all those PEEKs and POKEs I’d typed from Compute! Magazine were actually doing. It even revealed that there was this mysterious program called the KERNAL that ran the whole show!
I lost the book long ago, but I found the PDF posted on the Bombjack.org site and I strongly recommend it. It was great to re-read it 25 years later and finally understand the stuff that was over my pre-teen head 25 years ago.
First of all, let me say, I’ve come across your postings several times now in the last few weeks and I am now hooked on reading it. Thanks.
But, damn you! Damn you for putting those fabulously delicious looking photos of sushi all over you site. I am craving sushi now and have not been able to satisfy it.
I’ll have you know, I refuse to read your postings again until I have attended an all you can eat sushi bar.
So there.
Actually “Stay awhile….stay forever!” was “Impossible Mission” by Epyx, great game.
http://www.mobygames.com/game/c64/impossible-mission
I’m 39 now when I was 15 in 1986 I actually wrote a “Pong” game in 6502 machine language. I wish I still had that code … or continued programming … those were the good old days.
All people working in Information Technology can experience this “fast forget” that allows something just a few years old to become like stone age.
It is part of our discipline. Our digital friends get old very quick. And this gives us humans a lot of reasons to commemorate “old” times.
Distance between users and experts is drastically reducing. Machine incredibly growing complexity puts all of us almost on the same line.
It will get worse.
Our beautiful code was written on water.
But it is nice to think that that code contributed to build the current reality.
Let’s become philosophers,
and wait for the final SYS 64738
younger people will not understand.
check this: http://www.sys64738.net
marco (@mgua on twitter)
The old timers will remember this. It pretty much defines the mentality of developers who cut their teeth in the late 70s and throughout the 80s.
http://snurl.com/uuefl
To the point of this post, how much of this kind of thinking applies today? I dare say not much, if any, expect for people developing very advanced systems, such as biometrics, robotics, search, etc.
I’m a nostalgic too… best souvenir is my own BBS I programmed from A to Y. The Z part was a little ML code that was added to a 80 columns ML program that would make the 1200 bauds more friendly than own C-64 code. I remember the day a good fellow around the world made that for me then I downloaded it using ZMODEM protocol.
I still own all the stuff and one day I will plug all that again and spent a few nice evening for sure…
Pingback: Top Posts — WordPress.com
While I greatly enjoyed books like Peter Norton’s “Assembly Language Primer” and Ray Duncan’s “Advanced MS-DOS Programming”, I think the single book I look back in fondness with is the “Turbo Pascal 3.0 Reference Manual”. With only 376 pages, it managed to more than adequately explain the Pascal programming language, the IDE, and mysteries of MS-DOS programming I had no inkling of until then. And yes, I still have it. :)
So long ago! I had lots of fun. Good thing is that as a friend of mine used to say there is still plenty of room at the top.
Kevin
Pingback: links for 2010-03-14 - Nerdcore
Erik, I strongly agree that short books tends to be good books, in the absence of very good reason for them to be long. That’s a theme that you’ll already have seen in my reviews so far (Elements of Programming Style only 168 pages; Programming the Commodore 64, while fairly hefty at 611 pages, is amazingly slim for what it is). And you’ll see it more as the review series continues: the next four books that I plan to cover are all in or close to the 200-300 page range. As with programming, the ability to say what you mean is valuable, but the ability to say what you mean simply, directly and concisely, without leaving anything out, is the real gold dust.
This certainly takes me back… I never had a Commodore.. mine was the Tandy Color Computer 3 I got in 1985. Still have it but it’s been in storage for over ten years now.
Random Question: Did you go to a Montessori school?
Non-random answer: no.
In some ways, the atrociousness of the Commodore 64’s BASIC was its best asset. The Atari 8-bit BASIC was useful, intelligent, and very well-designed (for the era). I remember just fuddling around with it and would create drawing programs that used four joysticks for four different cursors, different functions, and could save them to tape.
On the C64, none of this was possible in BASIC without throwing the whole thing to machine language subroutines. Certainly, this sort of non-BASIC BASIC was beyond my ability, but for people who actually could manage it, it made that sort of “deep knowing” you’re talking about not only relevant but necessary in a way it wouldn’t have been if the BASIC had been more accessible and powerful.
The C64 was, to a very real degree, the last of the era of monolithic computing; a vast userbase whose machines were identical (or if not identical, extremely similar with any important differences fairly well-documented). There was a real payoff for efficient, ruthlessly optimized programming. Elements of this continued on in the 16-bit era with the Atari and Amiga machines, but after that, it was a-la-cart hardware.
Today, game developers in particular are at the opposite end of the spectrum; faced with slow, inefficient code, it’s usually just easier to wait for the next generation of videocard to make your bloated code run faster.
While I’m certainly not eager to return to the days of single-tasking, when “please stand by” actually meant “feel free to go make lunch”, when downloading a 64K program was a 30 minute experience (and, single tasking, meant you should go find something else to do for a while), and single-line BBSes whose email function was limited strictly to those users on that BBS, there was something lost in the process.
At the end of the C64’s mainstream life, the device was far better documented than any other comparable machine, and it was being used to do things that, quite frankly, the developers of it would have told you was impossible had you asked them at the end of the C64’s development cycle.
I can’t even imagine what today’s hardware would be capable of if that by-necessity ethos of coding efficiency was in vogue today.
Pingback: A nostalgia for efficiency. » Unhelpful
Just to comment on what Delusion wrote… on the one hand, I remember the sort of things people got Apple IIs to do, the degree to which the hardware got pushed to the limit by, as noted, necessity. Yes, it’s impressive to imagine what might be possible if programmers worked to squeeze every possible ounce of functionality out of today’s hardware, as opposed to waiting for next week’s hardware. On the other hand, due to the speed of change, such effort would be beyond wasted; by the time any programmer had mastered the level of detailed knowledge comparable to that of the master 6502-era hackers, he’d be five chip generations behind and his laborious attempts to get 15% more performance would be outdone by someones wristwatch.
Eventually, though, we will hit the limits of speed. “Death of Moore’s Law declared — film at 11.” I know, I know, but it’s a basic fact of physics that, sooner or later, we won’t find a way to go faster. We won’t find a way to make memory keep getting cheaper. We will always find more things we want our machines to do, and that “By necessity” era will come back — if it can. I honestly do not believe a single human mind, except perhaps for some very rare extremes, could contain, organize, and process all the information need to do to a modern quad-core processor and graphics card and networking card, etc, what you could do to a 6502 with, what, a 4K ROM or so? 16K ROM?
(The flipside is that the modern world expects/demands shared data formats, shared libraries for display, and so on, all of which add tremendous overhead. Could you write a GUI on “bare metal”, optimized JUST for your program, that would run far faster than Windows or OSX? I couldn’t, but I’m sure a lot of better coders could. Would that added speed be worth the loss of integration with all the other programs? Probably not. And we won’t even mention hardware compatibility issues.) (Which Delusion did acknowledge, not trying to claim he didn’t.)
From what I read around, I lament the Commodore 64 wasn’t part of the 8-bit computing scene in Brazil in the 80s. All we had — other than stuff we heard a friend of a friend of a friend had brought from a US trip — was TRS Model I, III and CoCo clones, Apple ][ clones, Sinclair membrane thingy clones, and CP/M machines. Oh, and MSX later.
Pingback: The long-overdue serious attempt at Lisp, part 1: which Lisp? « The Reinvigorated Programmer
Pingback: What is “simplicity” in programming?, redux « The Reinvigorated Programmer
Nice article! I’m also 42, and I had a similar knowledge of my computer–not writing entire programs in assembly, but creating subroutines called from BASIC as well as using Vertical Blank and Display List Interrupts for exotic effects and sound routines that executed in the background, controlled by flags set by the BASIC program. It was the next best thing to multitasking.
My machine of the day was the Atari 800, and the book was De Re Atari (which translated to “All About Atari” if I remember right.)
I miss the days where you could cycle the power and start over with a clean slate.
One of my fond memories of visits with my wife’s family revolves around her uncle John who had retired to a farm in Oregon near Corvalis. We were visiting them one vacation and John had purchased a C-64 to first learn about computers, and second to possibly use one to help manage the farm. He only had a tape drive, and while he was getting proficient in writing BASIC programs that mostly did what he wanted, he had some problems managing them. What did I do to help? I spent a couple of days with him writing a TOS (Tape Operating System) in C-64 BASIC that would allow him to pick his programs from a menu that were stored on that, or a different tape, and when he selected on, it would either run it, or prompt him to insert the proper tape, and then would run it from there! Less that 2 days, and he was like one of his pigs in a nice warm wallow! :-)
Anyway, your comments about the C-64 definitely brings back some memories from eariler in my computer software career!
Pingback: EastZoneSoupCube - links for 2010-04-18
Pingback: Are you one of the 10% of programmers who can write a binary search? « The Reinvigorated Programmer
Pingback: Steve Jobs “never had any designs. He has not designed a single project” | The Reinvigorated Programmer
All i can say is that i wish i had that back back in the day. kudos to everybody that could program in assembler.
The book URL is now a .zip instead of a .pdf… At 53MB zipped, I’m sure their bandwidth was hurting.
Just a heads-up :)
Pingback: NIBBLE » Blog Archive » Programmare il Commodore 64: ricordate il libro?
Nice post. Respec’, man.
I’m a little older, first commercial machine for me was an OSI Superboard II … still have it; last time I checked it still ran.
Must try it out again :)
Cheers!
Pingback: Programming Books, part 5: Programming Pearls | The Reinvigorated Programmer
Pingback: Pedro Newsletter 21.04.2011 « Pragmatic Programmer Issues – pietrowski.info
Pingback: Programmare il Commodore 64: ricordate il libro? | NIBBLE
Pingback: What is “simplicity” in programming?, redux | The Reinvigorated Programmer
Pingback: My early experiences with Commodore computers | The Reinvigorated Programmer
Pingback: I miss my Commodore 64 | The Reinvigorated Programmer