OK. Here’s a fun diversion. What are the oldest computer books you have:
The first computer book you read/used
The first Mac book you read/used
The oldest computer book you still own
The oldest computer book you still use
And here are my answers:
My first computer book was The Applesoft Tutorial (1979). I got this as a part of an after-school class in the early 80’s. It is what taught me how to program in BASIC.
My first Mac book is more fuzzy. I started using Macs owned by friends and at work, but didn’t actually use any paper documentation for quite some time. I think my first Mac book was (believe it or not), The Dead Mac Scolls (1992), a great book on how to repair early-model classic Macs. But around that time, I also started buying the various volumes of Inside Macintosh (volumes 1-3 published in 1985).
The oldest computer book I still own would be one teaching assembly-language programming on the TRS-80 CoCo. I no longer own that computer, but I still have some of its books.
The oldest computer book I still use today is a toss-up.
I frequently consult Design Patterns (1994) by the “gang of four” (Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides), to assist with my software development work.
I also frequently consult The C++ Programming Language by Bjarne Stroustrup. But I’m not sure if it counts as “oldest”, since I currently consult the fourth edition (2013). But I first learned the language from the second edition (1991), which I still own.
I’ve also got reference manuals for the Perl and Python programming languages, but I don’t use them much these days.
The oldest book that I still have is an intro to machine language from the British publisher Usborne. I used this, and another book from them about creating adventure games, with my Sinclair Zx81.
My first computer book: My first computer class was held at ITT Federal Laboratories for students when I was a junior or senior in high school, and I had a class in computer electronics when I was an undergrad at Caltech, but I was more interested in hardware then software. The old tech books I have are mainly electronics and optics.
My first Mac Book: First edition of Cary Lu’s The Apple Macintosh Book when it came out in 1984. Cary was a friend and colleague. I met him when were at Caltech, and was writing for him when he was an editor at High Technology magazine. His enthusiasm lured me to buy a 512K Mac in 1985.
Oldest Computer Book I still Own: I have the original manuals for my 512K Mac, MacPaint, MacDraw and MacWrite.
Oldest computer book I still use: I can’t think of any print computer book that I use regularly. When I need information on computers these days I look online. It’s easier to find and easier for my aging eyes to read.
I should add that outside of a couple of brief jobs after college, I never worked in computing per se. I worked for laser industry trade magazines and also wrote extensively about fiber optics and telecommunications, including books like Understanding Fiber Optics and Understanding Lasers.
First computer, Mac, and oldest book still own are all the same: the two-volume Macintosh Revealed by Stephen Chernicoff, from 1985. If I had books for TRS-80 programming, or BASIC in general, I don’t remember them.
Oldest computer book I still use is much harder, because most of the time I’m referencing the latest version of manuals. I’m going to say it is IMS for the COBOL programmer, Part 2: Data communications and the Message Format Service by Steve Eckols (1987). I also have volume 1 but that’s on IMS/DB which is easier to understand from the IBM documentation.
I also have Wickes, William C. (1980). Synthetic Programming on the HP-41C, but I didn’t buy it until around 1987. Does programming a calculator using computer assembly techiques count?
Fun topic idea. My oldest computer book is “360/370 Programming in Assembly Language,” by Ned Chapin. My oldest Mac book would have to have been volume I of “Inside Macintosh.” Eventually to include at least up to volume IV. And I still have the well-worn and Scotch-taped IBM System 370 Reference Summary pamphlet. Here’s a peek:
The Apple Macintosh book by Cary Lu. Read it cover to cover before getting my first Mac in 1985. Seems I was already under the Mac’s spell even before I had one on my desk.
My first significant book was the “Introduction to Programming” (part of the Small Computer Handbook series by DEC). I learned PDP-8 assembler from it.
The book I still use is the old IBM manual “APL\360 User’s Manual” to help with the free Dyalog APL app I use occasionally on my Mac.
Both books were from the early 70s. I tried learning 360 assembly but never got the feel of it from the IBM manuals. The DEC book was much more friendly and eventually made me love to program in assembler (on PDP-8, PDP-11, MC6800, MC68000 and 56001 DSP. Learning ARM64 now).
Oldest computer book I still own and occasionally consult: Human Interface Guidelines: The Apple Desktop Interface (1987). Wonderful small book. Still has the perforated reader response card in the back!
All the opcodes in order: AND TAD DCA ISZ JSR JMP IOT microcode (IIRC). I still remember after all these years. I probably had read a couple of FORTRAN books in the library, but Introduction to Programming was my first real encounter with a how-to-write-code book. I shake my head a little bit whenever someone refers to ARM as “reduced instruction set” – you don’t know the meaning of the word.
Don’t remember my first computer book but it would have been about Fortran programming.
First Mac book was David Pogue’s “Switching to the Mac”.
Since going mainly paperless I have few physical books. One book I have kept is Tutfe’s “The Visual Display of Quantitative Information”. Great reference for presentation graphics.
RISC seems to refer to a design which emphasizes other matters more than the size of the instruction set. Still, I would guess that the instruction set of the PPC and ARM architectures is smaller than that of the x86 or the 68k.
From memory, RISC seems to focus on single size instructions (usually 32 bit), a load/save memory architecture where no arithmetic can be done with a memory operand, many registers with orthogonal ISA and 3 operand instructions, etc. All to facilitate the use of the on-chip pipeline so the latency is no more than a single clock.
I enjoyed the PDP-8 instruction set since it was easily memorized and hand-assembled. I actually wrote all my code using the switches on the PDP-8/S. Those were the days…
Probably a few on Sinclair Basic no longer extant, but then, The C Programming Language by Kernighan & Ritchie and (big time), Applied Concepts in Microcomputer Graphics by Bruce Artwick. 3D graphics transforms! Aaagghh!
Ah, Memories. “Introduction to Programming” Is still on a shelf in my basement. 2s complement arithmetic was a revelation and relief after seeing the confusion of +0 and -0. I acquired a PDP-8 abandoned by other projects. Focal, an interpretive language sort of like Basic, was the foundation for automating measurement of spectral filter transmission curves. Using ideas based on Vern Soden’s adapters to convert I/O to TTL signals, several instruments were interfaced to the PDP-8 and Focal incorporated added subroutines to use them which were written in Assembler. I coded some and documented much of this. I coded some with pencil and paper while vacationing ‘up north’ with my folks.
My personal computer at the University of Michigan Space Physics Research Laboratory was one of the DEC DP-11s used to support spacecraft simulators. I wrote a RT11device driver for printers that converted carriage control in files downloaded from the Michigan Terminal System from logical to machine format.
I still have one or two Binders of the VAX/VMS manual set somewhere.
More power to you. While it is important to understand assembly language in order to be able to diagnose problems in compiler-generated code, I would never want to hand-write assembly-language code for a modern RISC processor. The instruction sets of these processors are designed around the needs of compilers, not humans. So you may find it a real pain in the neck to hand-write any non-trivial bit of code.
Unlike old CISC processors (especially IBM mainframes and DEC VAX systems), which were designed for human-written assembly code and have a lot of instructions designed to simplify that kind of code development.
Or they’re using a different definition.
In college, it was drilled into me that they key defining feature of RISC is that every instruction is the same size and can execute in one clock cycle. This greatly simplifies instruction scheduling and other internal housekeeping processors need to do in order to achieve high performance.
A RISC processor can have thousands of opcodes and still be RISC, as long as they’re all the same size and every one executes in a single clock cycle.
In other words, “RISC” does not mean a “reduced set of instructions” but a “set of reduced instructions”.
It’s really too bad this topic did not come up a few years back. I tossed out an entire book shelf of old books that covered, Linux, Routing, Switching, Windows servers, and many Macintosh volumes… ( including a well know internet guide )
I have the set of three of the “IBM Personal Computer Hardware Reference Library” These are the books that came with my fathers first home computer.
They came in small 3 ring binders & in grey boxes!
IBM Guide of Operations “First Ed” ( April 1982 )
IBM Disk Operating System by Microsoft “First Ed” ( Sept 1983 )
IBM BASIC Guide “Third Ed” ( May 1984 )
• The first Mac book you read/used - Macworld Secrets 2nd Edition 1994
• The oldest computer book you still own - IBM Guide of Operations “First Ed” ( April 1982 )
• The oldest computer book you still use - Sadly cannot think of time I used one of my old computer books recently.
I think the biggest problem with hand assembly using RISC processors is writing out of order code. As you said, the compiler knows how to do this much better than the programmer. I suppose one can learn the rules and use the large register set as much as possible to reduce memory accesses for simple tight loops.
But the advantage of learning assembler is to gain an appreciation of what the compiler does. Frankly, I find assembly languages to be much more understandable than the highly abstracted code which dominates object oriented programming. I have used it a lot over the last 25 years but never really got the hang of Obj-C or Swift programming.
