Readers in the UK or Commonwealth might be more familiar with the Usborne series of books for 8 bit computers.
The publisher has made them available from their website[0]. Here is a series of modern reviews from a friend of mine[1].
My favorite when I was a kid was the one that taught assembly language to pre-teens. I still think of cartoon robots putting notes into boxes whenever I assign something to a variable.
Computer Battlegames and Computer Spacegames were much loved in my youth. I wish I had seen some of the other books in the programming series from Usborne.
I remember my dad being super frustrated with me when I was very young. He was on such a different level (chip/board designer) that everything was so effortless to him, and he had serious trouble relating to anyone "beneath" him. It only got worse when he left when I was about 9. I always had trouble self-motivating, and it would hurt like hell when he'd show up out of the blue and express disappointment that I wasn't writing assembly yet or building my own circuits.
But the Usborne stuff, and the spectrum/vic20 games I played around that time, are treasured memories. Thank you for reminding me :)
Like others have posted, my childhood included a lot of typing in BASIC programs from books and magazines. What I remember most is staying up late one night when I was ten years old to type in the text adventure game from the back of "Basic Fun with Adventure Games" [1] on my TRS-80 MC-10 with 4K RAM. Before I could finish typing it in, I was shocked to get "?OM ERROR" -- out of memory. My first ever experience with running out of resources. :) I knew I was going to need a better computer...
The only difference with my introduction during my childhood was my father had a friend, who was building RAM extension boards (and other things) out of his garage, and he, excited that a kid was into computers, extended our TRS-80 for free. I can't remember the exact number at the moment, but it was something insane like 40Kb of RAM (But it was sometimes... Unstable).
I was the only one of my friends with a computer at the time, and we used to gather round and play BASIC games we either wrote ourselves, or write up the latest magazine game.
Oh, good on you for posting this. This takes me back to childhood summers spent hacking away at TI Extended BASIC trying to write my own games - with admittedly humble results. Or the evenings spent reading dot matrix printouts of other games' code trying reverse engineer the text parser. Or memories of playing Scott Adam's text adventures, the flight-sim SPAD, Parsec, Infocom's Witness, etc. Or attending Chicago TI user group meetings with my Dad - who eventually became the president of such IIRC. Or my Dad dialing up 300 baud modems to a BBS. Those were definitely good times.
Growing up I had a Commodore 64 and for some reason came into possession of another of David Ahl's books ("More Computer Games" I think it was called). It contained Eliza as one of the listings and it was a program that fascinated me so much I ended up creating a ton of clones, in horribly nested BASIC (though, to be fair, is there any other kind?)
On the Commodore 64, it was the only option. It had minimal support for a thing it called a "subroutine", but what it really was was a GOTO that pushed the source on to the stack and could be RETURN'd to that source. In particular, no concept of return value, no concept of parameters; everything's global. Modification of global values prior to the "call" is the argument passing, and modification of global values is the "return".
Commodore 64 BASIC, and 8-bit BASIC in general, was fully in the paradigm that Dijkstra was referring to when he wrote Goto Considered Harmful. (Not exclusively, of course.)
The 6502 processor itself also has very poor "stack" support, the hardware-supported stack is limited to 256 bytes at a fixed location. It's one of the things that make it hard to compile a modern language like C for the architecture, so even among compiled languages one would prefer something FORTRAN/BASIC-like.
To be fair, the 256 byte stack can essentially be used in assembly as 256 registers, which is also one of the features (along with indirect addressing) that make assembly on it awesome.
My relatively poorly researched impression of it is that it's half-way to portable C, with a proto-stack and pointers, essentially.
The on-chip stack on the 6502 was not intended to be used for implementing the stack for programming language procedure calls; it was intended to provide system extension functions that provide things missing in the 6502 instruction set,(for example, multiply), which had to be implemented with multiple instructions. For "modern" languages like C, 16-bit 2's complement integer arithmetic was expected but the 6502 native instructions were for 8-bit numbers.
They Create Worlds is a fantastic podcast in general, and I encourage folks with an interest in the history of games--or of computer tech in general, given the way it's historically tracked--to give it a listen. Alex is one of the true scholars of the topic.
There was an earlier version of this book -- less slick -- that you could buy from DEC. I had gotten a copy from my uncle.
At my public library we had a teletypewriter, with an attached paper tape punch and reader, and a phone-cradle modem, with which you could connect to the the PDP-8 at the local high school.
I recently bought an Osbourne "portable" -- seeing my children's delight as we booted up that ancient machine (from actual 5.25" floppy discs, no less) reminded me of own own sense of wonder at the same age, 40 years ago. Of course my middle-aged eyes didn't tolerate a 7" amber screen as well as they once did, but we proceeded to create an adventure type game, in MicroSoft Basic. The kids actually squabbled over who would get to play that simple game, very unlike them, such was their enthusiasm. And play they did, for many, many hours!
We had a bug where the player's "hit points/HP" could go negative. I loved watching my children deduce where the problem must lie, and debugging the problem. (comparison of <, rather than a <= )
They had lots of ideas for additions, some of which we implemented (others were very ambitious, bordering on Dwarf Fortress!) And even though what we created was very simple and crude, their pride in ownership was clear.
I have the very book you talk about ("101 BASIC Computer Ganmes", the DEC version from ~1973) on my bookshelf. In very poor condition, but there.
Many of my very first "lessons" in programming were from taking programs in that book and then translating them to BASIC as found on the VIC-20 and, a little later, the C-64.
I still often do that (just after "Hello World") when I'm first learning a new programming language... though these days it looks much more like just getting the requirements from the book than any sort of actual direct code level conversion.
Brings back fond memories. That was the book that got me started programming. I didn't even have a computer at the time but loved reading about the games and trying to understand the code by going through it in my head.
Hey, I can still remember most of the copy protection poem from Faery Tale Adventure. Them's some valuable neurons that won't be repurposed any time soon.
Do they? I had a childhood with Basic when JS and Python would've been available to me, basically because I didn't know better.
I made silly little programs with a friend, and we had grand plans for a Harry Potter themed MMO. Naturally, we started with a loading screen on a timer, (because that's what comes first, right?!) and got no further.
I grew up in the mountains, where everything was at least 20 years behind, and our school was well-stocked with 80s-era BASIC books in the library back in 2003. This was well into the Visual Basic era if we're talking beginners' languages. I still had the experience of typing stuff into Qbasic and I remember that fondly.
We had a book or two of Apple II BASIC programs in the school library. They had just enough Apple-specific BASIC in them that only the simpler, text-basd games were usuable at home on my PC with QBASIC.
For some reason nobody ever thought to put those books in the computer lab which was full of various Apple II's.
I wish there would have been more explaination of the code, it was pretty much a couple hundred lines of LET X1=15 IF L2 < 1 GOSUB 12100
I remember young me spending hours on a VIC-20 version of animal.bas ("Computer guesses animals and learns new ones from you"). Given enough time and training input the computer could answer any question put to it! It helped open my eyes to the magic of computation and still gives me a bit of a tingle when I think about it.
I really think there's something magical about beginners typing in whole projects by hand (instead of the modern copy-paste). It really helped me when I was getting started with programming.
To me, it feels like typing each character manually cements the knowledge in there much deeper than 'oh, I think I understand what I'm copy/pasting.'
Maybe that's a shallow truism by now, but I still see people struggling to learn programming via copy/paste from examples.
Learn Python the Hard Way is often blasted for adhering to that sentiment. I think it has value. I think LPtHW perhaps attracts ire first for other things, like a now dated bias towards python 2 over 3, but whenever I recommend it to beginners, people always get mad over its emphasis on memorization.
I get what they're saying (probably from dealing with too much rote school work in the past), programming is more about critical thinking than memory, but it really helps to have the core constructs memorized in a language. If you have to google "loops in python" every time, it's not going to go well.
That's a smart take. Even today when I'm learning something new I try to do as much physical typing as possible from the example because I feel like I learn it better.
The other day I had the thought of "all memory is muscle memory" - it's not literally true, but memorizing in an associated form builds up so many cues that it's worth applying to any study: do warm-ups and repetitions, speak, move, and think in sync.
I tend to think of it is holistic memory or whole body memory. The more functions you can involve subsystems in your body the more it hangs together in your brain for longer terms I think.
My first machine was a TRS-80 Color Computer 2 with a cassette tape drive; compared to the PET, due to the "generation difference" (probably in the encoding method?) - plus Radio Shack - it's cassette storage was actually really reliable.
People are still pulling old software and data off of some of their old CoCo tapes, what little problems there are typically can be solved by dumping to digital file and editing in some audio software to clean things up.
My first computer was a TRS-80 Model I. The cassette tape storage was just Radio Shack's regular tape recorder. For some reason you had to use different volume settings for BASIC and machine language programs. The volume setting was horribly imprecise and I was always having to reload programs. The Commodore 64's tape recorder was a big upgrade.
I've got a related question: I'm looking for a (BASIC) programming book I loved as a kid. I can't quite remember the title, but it was something like "Programming for kids from 8 to 80".
Googling for it doesn't help, all I get are references to the 80s, or the TRS 80, or some such.
Does anyone remember this book, or where I can find it?
I have such fond memories of coding in these BASIC games with my dad at our C64 when I was six or so. Honestly the most memorable part was the night I got to stay up late, while he and I spent hours trying to figure out why this one little problem kept appearing. My first late night debugging session.
The People's Computer Company published What to do after you hit return. It was a large format book that collected many of the games published in PCC Newspaper, People's Computers, and Recreational Computing. PCC, before the microprocessor, ran storefront computer centers in the Silicon Valley and promoted the personal use of computers worldwide. There is a whole generation of kids who celebrated birthdays by going to PCC to play BASIC games.
Bob Albrecht, the Dragon and fellow PCC founder, has always been passionate about teaching kids BASIC programming and still volunteers in local schools. He has written multiple books on BASIC mostly targeted at newbies.
One thing no one has mentioned are the BASIC functions PEEK() and POKE() which allowed BASIC programs to read and change memory. Many people learned about control registers and machine language experimenting with PEEK and POKE.
PCC also published The Computer Music Journal and Dr. Dobbs Journal. Dr. Dobbs Journal: running light without overbyte started when the Altair microcomputer was delivered with almost no memory and no software. PCC curated the development of personal computer software
including Tiny Basic. The TRS-80 integer BASIC was a variant of Tiny Basic.
The Dave Ahl books include many games that initially appeared in PCC publications.
Star Traders was designed and written by Dave Kauffman who was one of the People's Computer Center staff. It was many people's favorite. Another PCC game, Hunt the Wumpus, written by Greg Yob, has been a favorite of AI researchers as well as computer game freaks.
I learned programming on a Timex Sinclair (2 KiB) with the book Brain games for kids & adults using the Timex/Sinclair 1000, 1500 & 2000 series. There were other editions for other platforms (Apple, Commodore, etc.)
It consisted of 26 games/puzzles, one for each letter of the alphabet. Went looking and found this little treasure trove:
Had great times with this one and the "More Basic Computer Games" book.
My favorites were the Eliza clone, and ICBM, where you are trying to intercept an incoming ICBM with a anti-ballistic missle. My first use of trig functions, which really helped solidify the concepts to me. I also converted the 2-D version to 3-D (with altitude) for even more fun.
I was originally using a TRS-80 Color Computer, with a slightly different dialect of BASIC, so I was usually having to make modifications. Which also helped me learn programming.
> I was originally using a TRS-80 Color Computer, with a slightly different dialect of BASIC, so I was usually having to make modifications. Which also helped me learn programming.
Same here! Those two books, along with a ton of magazines and more than a few other books, plus one I found that had "conversions" - helped me greatly to learn programming as a kid.
I eventually found a great book on Fortran graphics - which I also started converting (Fortran and BASIC are very similar).
There's a third book in the "Basic Computer Games" series - I don't recall exactly it's name, but you can probably find it on archive.org. It had a blue cover, and I believed it dealt with much larger, adventure-style games.
Not to mention, there were special editions created for Radio Shack and the TRS-80 as well...
Between those, tic-tac-toe learning systems, the various 20-questions things...
Later I played with various "expert system" stuff, then there was David L. Heiserman's "Machine Intelligence" and "Robot Intelligence" books...
I tried to understand early neural network stuff, but I could not get my then teenage head around it; in fact, none of it became clear until I took Andrew Ng's "ML Class" in 2011 as an adult (part of the key was understanding the role of linear algebra and matrix math in the system - among other things - that class was the first that explained it very clearly, and the use of octave was also a revelation).
Since that class, I've continued to play with ML/AI, mainly via a couple of courses thru Udacity (including their "self-driving car engineer nanodegree").
I was a ACM National lecturer and gave a formal version of my Computer Faire talk, EPIC COMPUTER GAMES, written with Lee Hoevel. The talk (and article) described a visit-travel-explore-discover game played in a virtual space. It suggested that the user interface could be natural language, which could be done using an Eliza-like system. Computers then were mostly textual so instead of shooting with laser guns disputes were to be resolved by solving problems or completing riddles.
I had an Atari XE when I was 9. I used to write all sorts of games with it, starting with simple which way book type games and then moving on to 2 step animation and movement. I didn't have the optional floppy, so when I shut off the computer, my work was gone. I used to write the code in a notebook and have to type it in again. I used to keep it on and switch the TV back to TV and raise hell if my mom turned off the unit.
Then I moved on to a PC JR with Cartridge Basic and after that QuickBasic on Windows 3.1.
Back in the 90s I learned a lot from the Prodigy QBasic community. There were some really cool games that people contributed, they have to be out there on the web somewhere.
Heh - you may have ran into some of my old stuff from back then, up thru the late 1990s or so. BASIC still holds a place in my heart (if you haven't played with QB64, you owe it to yourself to look it up).
For that old stuff, "Pete's QB Site" still holds a lot of it:
Not just that we expect to, we can. Back in the day you could download them as well, but it costs a lot of money: someone had to pay for the computer and phone line and then one computer per phone line was common. It also took a long time to download files at 300 baud, and often you were paying long distance rates to the phone company (which was far more expensive than long distance rates now despite inflation). Most of us were using audio cassettes to store our programs on, dreaming of a floppy disk that held 80k... (we knew hard drives existed, but they were so expensive that we didn't dare dream of them)
While it was possible to buy a multi-user computer, or a connection to the internet, we didn't even know such a thing existed. Not that it mattered, as practically the cost was far our of reach.
I never heard of that until much latter. There wasn't a dominate computer platform: as a kid I knew people with Apple II, C64, Atari, or TI. They were not compatible in general, so it doesn't really make sense to air such things. Even assuming the recording would work, my memory of cassette systems is they rarely worked. I typically saved everything to 3 different tapes to have a hope of reading back correctly eventually.
There wasn't a dominant platform in the UK either. We had multiple machines from Acorn (inc BBC Micro), Sinclair, Dragon and Amstrad plus the Commedores and Atari's you had too.
I don't think Apple really came to Europe until much later.
> we knew hard drives existed, but they were so expensive that we didn't dare dream of them
I was from a slightly later generation (I think); I got my first machine in 1984. I knew hard drives existed too - a 10 meg system would only cost about $8000.00 back then that would connect to my machine (TRS-80 CoCo 2). Sigh.
As far as "multi-user" was concerned - well, we had OS-9 - if one could afford it (plus you needed a dual-floppy system if you didn't want to be swapping all the time). It could support multiple users, but it needed some special hardware for it.
As a kid, I later got a CoCo 3 (sometime around 1987 or so) - and I ended up building a null-modem cable to connect both of them, so I could "share" programs from the floppy drive on my CoCo 3 to my CoCo 2. I also experimented around with BBS coding using that setup. It was my first "network", so to speak.
Not really in terms of just listings of code, but there are plenty of 'Learn Language X Through Games' type of books like 'Land of Lisp' or 'Automate the Boring Stuff in Python' that have the same feel.
Typing in a program from a paper source forces you to think about each line you're entering, it's more than just a 'slow way to distribute a program', it's also a teaching exercise along the same lines as how writing your notes in class are part of the learning exercise that reinforces your mental model of the subject.
I remember typing in a quiz-show game from "More BASIC Computer Games" (the sequel to this book) and somehow ending up with it displaying the answer and expecting the question. My dad helped me debug it. I was around seven years old at the time; I entered quite a few of the games in that book into our Tandy 1000 TX, using the ZBASIC compiler and editor, moving on to writing my own programs once I understood what I was copying. I've come to recognize that experience as one of the foundational pieces of my long-term career development.
Most of the lines I typed in where "2050 data 100,98,0,0,45,128,..." up to the maximum line length (256 character?) at which point it was "2060 data...." Nothing to learn there. I suppose I could look up each opcode and figure it out, but even then there were no names to guide me as to what anything means.
You were either typing in mostly game code (with a simple BASIC HEX ML loader), or were using a machine with a limited form of BASIC that didn't allow for easy graphics manipulation (the C=64 and VIC-20 were famous in this regard).
While I recall doing the same on my machine (TRS-80 Color Computer) - it was usually to get functionality that was lacking otherwise. I recall having to type a ton of DATA statements for an ML program that would give you simultaneous graphics and text on screen, like it was a native mode. Then there was another program (called "Bells and Whistles") that was essentially a 4-track music editor, similar to 90s era "tracker" programs; you could define simple waveforms as different "instruments", then build your music in a note-by-note "tracker" style - except the tracks ran left-to-right, not top-to-bottom! It would then output the music and show the notes playing (scrolling) - four channel, 6 bit music, with user-defined waveforms and envelopes. Truely amazing at the time!
Especially considering the TRS-80 CoCo did -not- have a sound chip. It was all done by the CPU and a 6-bit DAC (which was also used by the cassette tape interface for storage, as well in a convoluted manner by the joysticks).
I was probably typing in a program that was written in assembly language, and then the bytes were output so that I didn't have to type in the assembly code (which would be even more keystrokes with only limited additional ability to understand, not to mention everybody has BASIC, assemblers were rarer).
I was doing this on an Atari 400. There was plenty of power available from BASIC to get at the graphics and sound, but there wasn't the speed. BASIC was an interpreted language and so you had to drop to assembly to get enough speed for a large program to not feel slow.
Funny enough, this is my PhD research. Granted, I do agree that the examples should be more meaningful; however, offering students worked examples as typing examples to better train them on syntax errors is the general feel.
Really, you type in codes/programs from paper printouts for your PhD? I knew that some programming communities in academia still clung to old habits and way of doing things, but not like that!
No, I developed a platform that converts code formatted from TinyMCE into a PNG which is then an exercise for students. Students in turn retype out the program. The activity requires zero high level thinking, but presents a worked example of a CS concept. Since novices struggle initially with syntax errors, the exercise serves as a scaffolded process of practicing typing syntax without also trying to problem solve [1]. The hope and thought process is that the exercises get students comfortable with writing syntax without problem-solving so that when they DO problem-solve, they can rely on muscle memory.
The platform is currently deployed at NC State as an optional exercise for some of the classes and while there is no explicit "those students did better" (yet I hope...), I do have promising information like regular completers earn high final grades in the course and even potentially as an intervention tool for lower performing students. In that context, students that regularly performed lower on midterms scored higher on the final and earned a higher final grade than students that just "looked at the exercises" (it is optional). My current hypothesis on that data is that poor performing exercise completer's realized they needed additional practice, which helped boost their skills.
My comment history goes in better detail, but I describe it akin to drilling in other technical skills like cooking, music, dance, martial arts, etc.
I think this as an activity is one of the methods that causes much of the "prior experience" seen in some higher performing CS students. They learned about syntax errors and tweaking code while making these BASIC games, or in modern contexts like modding Minecraft.
Moving forward, my research then goes into optimal exercise sequencing for learning CS. If you are compiling more syntax errors during a traditional coding exercise, maybe do a few typing exercises or output prediction exercises before trying to code.
I will add though that I do attempt to retype code I find on StackOverflow rather than rely on copy pasting. I'm a PhD student that can't extract a tar file or correctly set up an Apache server configuration because I work primarily on a Windows machine and it's "not needed" for my career path. However, this lack of ability annoys me, so either I continue to rely on SO and having the Internet to save me, or I learn to do it myself.
Wow, I had this exact book and I believe I typed every last program into my Commodore 64. Including the (to me) massive Super Star Trek game, which I did over the course of several evenings. Ended up porting that one to the PC as a way to learn Pascal. What a trip down memory lane.
I guess Gorillas and Nibbles didn't come with that book from the article, but with MS-DOS, so to have it with the book would have been a waste of space as they were already present on most systems
The first "programming" I ever did was when we had computer day in third day, I bet a kid I could get to a higher level of Nibbles than he could. I read a BASIC book from the library, found the script and changed the START_LEVEL variable from 1 to 100. 20 some years later, I write code for a living.
That book was somewhat "old" when I first encountered it as a kid in the 1980s. Most of the code in it was first created for minicomputers in the 1970s, probably running some form of Dartmouth BASIC.
this book brought me so many hours of joy as a child. I typed these programs in and read it over and over again. I remember now parts that I didn't understand (like Nim) and being amazed at some things people could do in BASIC (https://www.atariarchives.org/basicgames/showpage.php?page=4).
> being amazed at some things people could do in BASIC
My first software engineering job out of highschool used a version of BASIC; I was originally hired as an "operator" because I didn't have a degree, and they wouldn't hire programmers without degrees. So they trained me on how to load 9-track tapes on a vacuum-column drive, as well as how to load up greenbar and run reports on the system. It was an IBM RS/6000 running AIX (my first encounter with Unix), and VT-100/Wyse-370 terminals via a serial concentrator - but our main system ran on top of that; it was called UniVERSE, and ran a variant of Pick BASIC:
They gave me access to the system, and their sysadmin gave me a copy of a "Learn Pick BASIC" book. The company was a small mom-n-pop shop that created insurance claims management software for small insurance companies administering our state's indigent health care system.
I started writing various pieces of software - an adventure game, playing with the printers (made one of them play music - not a good use of company resources), just having fun while in between actual "jobs" given to me by the real programmers (run this report, or load this tape). Well...someone was monitoring me and my coding.
They started to give me small tasks - fix this problem with this piece of code, or build this kind of report, or can you make the printer do this?
Within six months - after I had graduated a local tech school and got my "degree" - they hired me (at a pitiful rate that irks me today, but I was a young-n-dumb teenager at the time). I stayed there for a couple of years, learned more Unix, became intimately familiar with terminfo settings, helped to build a text-mode windowing system for their product, got involved with the Amiga scene...
Ultimately, it was my beginning of a career I enjoy and love to this day; but I do have to say I miss the Wyse-370 terminal (it had a Textronix vector graphics mode I played with as well - plus it was just a great terminal overall - they can still be purchased today, but supply vs demand has kept their cost high, so I've never purchased one).
Back then, you didn't have a choice. Most microcomputer BASICs did not have any other kind of "infinite" looping construct beyond a GOTO. FOR-NEXT was about the only other option.
There wasn't a WHILE or a DO-UNTIL construct in those BASICs, with the exception of (IIRC) or the BASIC used in the MSX systems (which didn't see much action outside of Japan) and in BBC BASIC (it was probably the best BASIC out there along with Microsoft's - but again, not as well known outside of the UK).
The publisher has made them available from their website[0]. Here is a series of modern reviews from a friend of mine[1].
My favorite when I was a kid was the one that taught assembly language to pre-teens. I still think of cartoon robots putting notes into boxes whenever I assign something to a variable.
[0] https://usborne.com/browse-books/features/computer-and-codin...
[1] http://www.asciimation.co.nz/bb/category/usborne