30 Years of Code

Thirty years ago this month I wrote my first program. I'd first seen the IBM 1130 demoed at my high school's open house a couple months earlier. This guy put in a deck of cards, typed a month and year at the console, and out popped the corresponding calendar on the line printer. I thought "Cool! I want to learn how to do that!". But it wasn't until soccer season was over that I had time to follow up.

My first program wasn't much--a few lines of Basic. But I could see how the principles could be applied to write more interesting programs, like the calendar generator. I was hooked.

It didn't take long to bump into the limits of that Basic implementation, like 2-character variable names. So I moved to Fortran. It was pretty neat, too, but there were some limitations imposed by the Fortran runtime system. For one thing, all the I/O was synchronous. And since the operating system didn't do any spooling, you weren't just waiting for the OS, you were waiting for the device. So it was slow. For another thing, it wouldn't let you generate arbitrary patterns with the card punch.

So that led to assembly language. You could do asynchronous I/O. And you could compose 80x12 bitmap images and punch them on cards (the 12 punch locations in each card column mapped to 12 bits in each 16-bit word).

By the time I was a senior, we had a 6800-based[1] microcomputer, which a couple of the other students had built from a kit. It had a keyboard, a CRT, a simple ROM monitor program, a speaker, and an I/O port that you could hook up to an audio cassette recorder. The audio cassette was the one storage device. You stored your source code--6800 assembly language--on a cassette. After the assembler read it in, you popped out that cassette and popped in a new one, and the assembler wrote the binary image to it. You then loaded your binary back into the system using the ROM monitor. It made the IBM 1130 Fortran look blazing fast.

So one of the first things I did was write a binary patch for the assembler. The patch added an option to write your binary directly to memory. Once we had that working, I had great fun coming up with algorithms for making different sounds on the speaker. I wish I'd saved some of those programs; I remember that some of the sounds were pretty interesting.

I hope I'm still writing code 30 years from now. Software is such a great blend of functionality and plasticity.


[1] No, that's not a typo.

Comments:

6800! I remember those days, although, my own memories lead down the 6502/6510 lane.

I wrote my first BASIC program on a Commodore PLUS/4 when I was nine years old. It enabled one to draw on the screen in 320x200 1-bit mode using the cursor keys. My next BASIC program was a copycat attempt to write a word processor. I was 11 at the time.

Eventually I was able to sell the PLUS/4 (nobody else had one, so no software, and worst of all no games were available for it), and I got a Commodore 128D for Christmas from my aunt & uncle. It had a 1571 double-headed drive, a Z80 AND a 6510 CPU, ran CPM, but best of all, it could be reset into Commodore 64 mode by holding the C= key and pressing the reset button.

It was 1987, the cracking scene was at its zenith, and I had a C=64 compatible system with tons of cracks \*AHEM\* software available for it (in the country where I partially grew up, no originals were available to buy anyway).

Soon enough I wanted to code intros like the famous crackers did: Hotline, and IKARI, and G\*P and Legend, and, and, and... BASIC just wouldn't cut the mustard.

So I hooked up with a local software pirate, and got a recommendation for a great book on learning the C=64 internals and the 6502/6510 assembler.

The journey began. Thanks to learning assembler back then, I'm pretty much able to program anything in any language today, if need be.

Some time in 1993, I finally managed to scrounge up enough money working to buy my first Amiga 500; this time around, I jumped straight into the Motorola 68000 assembler and intro coding on the Amiga.

Those were some of the best times on the scene, bar none. Ever. No other environment and no other computer had ever been able to replicate that kind of atmosphere for me.

Sometime in 1994 I had my first contact with UNIX, and luckily for me, it had been a SPARCStation 20 (serving an entire country!) with 4 HyperSPARC CPUs and Solaris 2.5.1.

The rest, as they say, is history.

Posted by UX-admin on December 23, 2006 at 03:40 AM PST #

Post a Comment:
Comments are closed for this entry.
About

Random information that I hope will be interesting to Oracle's technical community. The views expressed on this blog are my own and do not necessarily reflect the views of Oracle.

Search

Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today