Typing In Apps
When Programming Meant Typing It In
The Commodore 64, computer magazines, and the strange art of turning a pile of printed code into something that actually worked
There was a time when you could walk into a store, buy a computer magazine, and discover that you had just purchased a piece of software.
Not a download.
Not a floppy disk tucked inside the magazine.
Not a QR code.
You got paper.
And if you were lucky, you got about ten pages of BASIC code printed in tiny letters.
If you were really ambitious, you got pages and pages of numbers that looked absolutely nothing like a computer program.
Then you went home, turned on your Commodore 64, and started typing.
And typing.
And typing.
And if you made one mistake somewhere around line 740, congratulations: you were about to become very familiar with debugging.
Before the Internet, the magazine was the download
Today, the idea seems almost ridiculous.
We expect software to appear almost instantly. You search for an app, click a button, and a few seconds later it is sitting on your phone.
Back then, the magazine itself could be the delivery mechanism.
Magazines such as 3-2-1 Contact introduced young people to computers with relatively simple programs. But if you had a Commodore 64, you could go considerably deeper.
There was COMPUTE!.
There was COMPUTE!'s Gazette, aimed specifically at Commodore users.
There was RUN.
There was Ahoy!.
And there were other computer magazines catering to Apple, Atari, TRS-80, and other machines.
These magazines didn't merely talk about software.
They printed the software.
It started innocently enough
A simple BASIC program might look something like this:
10 PRINT "GUESS MY NUMBER" 20 N=INT(RND(1)*100)+1 30 INPUT "YOUR GUESS";G 40 IF G=N THEN PRINT "YOU GOT IT!":GOTO 70 50 IF G<N THEN PRINT "TOO LOW":GOTO 30 60 PRINT "TOO HIGH":GOTO 30 70 PRINT "CONGRATULATIONS!"
That was understandable.
You could read it.
You could change it.
You could make the number range larger. You could change the messages. You could turn it into a game.
You were not just using a computer.
You were modifying the computer's instructions.
Then the magazine got serious
Eventually you ran across programs that didn't look so friendly.
You might start seeing things like:
100 POKE 53280,0 110 POKE 53281,0 120 PRINT CHR$(147) 130 X=INT(RND(1)*39)+1 140 Y=INT(RND(1)*20)+1 150 ... 160 ... 170 ...
For a kid who was just learning BASIC, this was where the magic started to happen.
POKE didn't look like normal programming.
It felt like you were reaching inside the machine.
And, in a sense, you were.
The Commodore 64 exposed a tremendous amount of its hardware through memory addresses. By putting particular values into particular locations, a BASIC program could manipulate the screen, colors, sound, sprites, and other hardware.
Suddenly the computer wasn't just calculating numbers.
You were talking directly to the machine.
And then came machine language
This was the part that separated the casual type-in programs from the really crazy stuff.
You turned the page and suddenly the program looked like this:
0800 A9 00 8D 20 D0 0805 A2 00 BD 00 C0 080A 9D 00 D0 E8 080F E0 20 D0 F5 0814 60
What the hell was that?
Those weren't BASIC commands.
Those were hexadecimal representations of machine-language instructions for the Commodore 64's 6502-family processor.
And yes, there were people who actually typed them in.
MLX: because apparently we weren't suffering enough
Computer magazines eventually came up with a solution to the inevitable problem of typing hundreds of machine-language values from a printed page.
MLX.
MLX was a machine-language entry system published by COMPUTE! for entering programs into computers such as the Commodore 64.
Instead of simply typing a gigantic program and hoping you didn't make a mistake, MLX could check the values as you entered them.
The process was something like this:
- Type in the MLX program.
- Save it.
- Run MLX.
- Open the magazine to the machine-language listing.
- Type in the hexadecimal values.
- Let the computer complain when you screwed something up.
- Fix the mistake.
- Continue typing.
It sounds primitive now.
At the time, it was pretty damn amazing.
Imagine being a kid in 1985
Imagine sitting in your bedroom with a Commodore 64.
The television is your monitor.
The Datasette or floppy drive is sitting beside you.
There is a computer magazine open on the floor.
You have spent the last three hours entering a program.
Your fingers hurt.
Your eyes hurt.
And now the computer is telling you that something is wrong.
You stare at the screen.
You stare at the magazine.
You check line 350.
You check line 360.
You check line 370.
Eventually you discover that you typed 53280 instead of 53281.
You fix it.
You type RUN.
And suddenly...
It works.
That little machine sitting on your desk is doing something that didn't exist on it a few hours earlier.
That feeling was different from downloading an app.
You didn't just acquire the software.
You participated in creating it.
The really crazy part: useful software
These magazines weren't limited to little games.
They published utilities, graphics programs, databases, programming tools, music programs, and even surprisingly capable applications.
One of the famous examples from COMPUTE! was SpeedScript, a word processor distributed as a type-in program.
Think about that for a moment.
Someone printed a word processor in a magazine.
You typed it into your Commodore 64.
And your computer became a word processor.
There was no app store.
There was no download button.
There wasn't even necessarily a disk included with the magazine.
The source code was the product.
And that changed how you thought about computers
This is the part I think we sometimes miss when we look back at this era.
The limitations were frustrating.
Typing programs was tedious.
Computers crashed.
Floppy disks failed.
Tape drives were painfully slow.
A single typo could ruin hours of work.
But those limitations also forced you to understand what was happening.
If your program didn't work, you couldn't simply reinstall the app.
You had to figure out why.
You learned what a variable was.
You learned loops.
You learned conditional statements.
You learned memory addresses.
You learned hexadecimal.
You learned about the processor.
You learned that the computer wasn't magic.
It was a machine that followed instructions.
The Commodore 64 was an incredible teacher
The C64 was inexpensive enough to put into a lot of homes, but powerful enough that curious kids could go much deeper than the BASIC interpreter that greeted them when they turned it on.
You could write a little guessing game.
Then a bigger game.
Then graphics.
Then sprites.
Then sound.
Then you started wondering how somebody else was making the really impressive stuff.
And the magazines were sitting there saying:
Here. Type this.
So you did.
There was something wonderfully democratic about it
You didn't need a computer science degree.
You didn't need to work for a software company.
You didn't need permission from anybody.
You needed a computer, a magazine, some patience, and enough stubbornness to type several pages of code without throwing the magazine across the room.
A kid could take a published program and change it.
Change the colors.
Change the characters.
Change the rules.
Add a feature.
Break it.
Fix it.
And eventually write something completely different.
That was programming education before programming education became an industry.
Maybe that's why those old listings are so memorable
When you see one of those old BASIC listings today, it can look almost absurd.
Line numbers everywhere.
GOTO.
GOSUB.
POKE.
PEEK.
Cryptic memory addresses.
And then the machine-language listings with their endless columns of hexadecimal numbers.
But there is something beautiful about them.
They were an invitation.
The magazine wasn't saying:
Look what somebody else made.
It was saying:
Here are the instructions. Now make it yours.
From 3-2-1 Contact to the Commodore 64
Maybe that's the progression a lot of us experienced without realizing it.
3-2-1 Contact: Computers are fascinating.
Basic type-in programs: Wait... I can make the computer do things?
COMPUTE! and COMPUTE!'s Gazette: Wait... I can actually program this thing?
MLX: Wait... I can talk directly to the processor?
And somewhere along the way, the machine stopped being a mysterious electronic box.
It became something you could understand.
Something you could take apart.
Something you could rebuild.
Something you could make do something it wasn't doing yesterday.
And that's a pretty damn good way to learn
Today we have incredibly powerful computers sitting in our pockets.
We can download software in seconds.
AI can write a program for us.
A modern phone has more computing power than the machines we thought were miraculous back then.
But there was something special about opening a magazine, seeing six pages of BASIC, and thinking:
"I wonder if I can get this to work."
Then spending the afternoon finding out.
Because sometimes the best way to learn what a computer can do...
...is to make it do something.
And if you remember the Commodore 64 era, you probably remember the sound.
The keyboard clicking.
The floppy drive grinding.
The television humming.
And eventually the unmistakable moment when you typed:
RUN
and waited to see whether your three hours of typing had actually produced a computer program.
Sometimes it crashed.
Sometimes you had a typo.
And sometimes...
the damn thing worked.
And when it did, you had built something.
Even if all you had really done was type it in.
Not asking for sympathy. Asking for understanding — and maybe remembering a time when computers were still something you could get your hands dirty with.
Comments
Post a Comment