DEV Community


Posted on • Updated on

My Coding History - Part 1

Why Write this?

I have seen other people posting something like this and would wonder why they did. My reason for doing so is the same reason I post anything - it's something I might otherwise write in an email to someone, but this way I can write it once and send people a link.

Or even better, I can pull out suitable quotes and then let a link to the whole post be just for anyone masochistic enough to want more detail or context.

Very Beginnings

This may seem a like a strange thing to say, but I saw a program running long before I ever got a chance to write a program. By now though, I have no clear recollection of when that was. Using a vague memory of exactly where I was, it was probably sometime in lower high school.

  • That's going to need explaining. In my day, in the part of Australia where I grew up, Primary school went from Grade 1 to Grade 7, then High school went from First Year to Third Year, after which most students left. The remainder continued and did Fourth and Fifth Years. Actually my cohort were among the first to rename those Years 8 to 10, then 11 & 12. My understanding is that this structure has long since changed,

To give this a year point, we're talking 1975 to 1977.

For a week, there was a Computer in the school. I remember my class was taken to see it. It was a drab olive box and the brand name was WANG. I don't recall anyone making any jokes about the name, that wasn't a slang term we used.

Some part of the box shape had a built in keyboard and screen. My only memory now of watching it perform was that it ran a simple command line artillery program. I think it asked for an angle and some kind of firing strength and would then print to screen the distance covered by the projectile. As a game, it ran in a loop so that you could "play" at trying to adjust the parameters in order to get a desired target value.

Having visited, we went back to our class - that was it. That was me seeing a thing and learning that thing was a computer.

  • It is hard to be sure what model I saw. Based on a colour memory, it was probably some version of the Wang 2200
  • Wang 2200

The idea of it must have stayed with me quite well. When I came to school for Fourth year we were given advice that we would be allowed to buy approved calculators for use during our next two years. As I was doing the "hard" subjects of Maths II & III, Physics and Chemistry, the calculator would be for that. Most of the students chose a Texas Instruments TI-30 because it came with a book, but I preferred a National Semiconductor model. In practical terms these were the first generation of affordable (e.g. for schoolkids) "scientific" calculators.

  • Some searching leads me to think I had this one, the National Semiconductor 4650
  • NS4650

  • So, another aside. This time: calculators. By this time, small simple calculators were becoming quite available. Oddly, I don't have clear memories about the simpler ones and whether or not we were allowed to use them at school. Perhaps because my schooling involved no use of them until the above mentioned directive to have a scientific one. Maybe we weren't allowed them, maybe we were, I just don't recall.

I should mention that the big caveat with us having calculators was that we were going to be the last year who were not allowed to use them in our final (year 12) exams. For us, it would still be the world of log tables and slide rules as a necessary skill even though we had the calculators for general convenience. When I did my final exams, on all my papers I added the letters "SRA" to indicate that any calculations were to "slide rule accuracy". And yes, that meant for two years, a practical physical dexterity that I maintained was for the accurate manipulation of a plastic slide rule. (Mine only lasted a year after year 12 before becoming too warped to be usable.)

So, that means in 1978 I had a capable calculator in my student hands every day. Doing Maths 2 and 3 meant I was learning calculus and probability. Somewhere in there I would have learned about parabolas and in Physics I might have learned about trajectories. At some point I twigged that I could use the calculator in a repeatable sequence of actions - and thereby emulate what I'd seen that Wang computer do, years before.

Again, memories are now vague, but I recall that at some point I was making up my own 3D parametric equations and having friends try to guess where a spot in space was going to be at the next round of calculation.

Still on calculators, somewhere in those years, my much older brother was by then working as a trainee surveyor and had bought himself a $300 Hewlett Packard calculator. This was before I had my scientific calculator. I looked over my brother's shoulder as he learned how to use it - and in particular, its use of Reverse Polish Notation. This fascinated me, and I suspect laid much of the groundwork for my eventual path. There's something inherently like programming in the need to restructure an intended calculation into an RPN sequence.

  • My patchy memory had this as the HP-35 but my brother has since informed me that it was instead the HP-45
  • HP-45

Again, like with the Wang, RPN stayed with me as a concept even though I never again had a device of my own that used it.

I don't recall which of my subjects included this next bit, I only remember which room it was in. I can remember the room because the school - as was common in those days - had been expanded in size by having numerous added D and T classrooms (Demountable and Transportable respectively). This class was in one of the Transportables.

What happened was this:

  • we were taught a bit of a programming language - I do recall that it used line numbers.
  • we were given piles of "punched cards"
  • we were given a paperclip, which we unbent and used to poke holes in the punched card.

We would write out our program on paper, get our teacher to check it for obvious errors and then we would sit and punch out the holes in our cards so that we had a stack of cards as our program.

All our stacks would be bound by an elastic band and handed in to be sent away.

About a week later, we would have the next class and by then we would hopefully get a resulting printout. This will have been the first time I that I saw 132 column "computer paper".

  • computer paper

I don't have any recollection of what programs I wrote. I presume I merely did what the lesson called for. I also don't have any memory of what my printed output was like. Did my programs work? Were there surprises? No recollection at all.

I can remember two other words or terms:

  • WARCC - because this was the term on the form we had to fill out to go with our card stacks.
  • Monash - which I think was pre-printed on the cards.

Strangely, "Monash" messed with my head for years as I didn't realise it was the name of a university and then when I did hear of it, I didn't realise that particular university was on the other side of the continent.

Apart from that short-lived class, and my dogged calculation games, no other awareness of computers came my way until the year after Year 12, when I moved to the city of Perth to attend the University of W.A.

  • So another aside. My passion in those years was electronics, with a bent for audio circuits due to my brother being an enthusiast for the new thing of "HiFi". I started buying electronics magazines, and having no other conception of self-learning, started avidly reading them - somehow hoping to eventually make sense of them, as if learning by osmosis. To add to my brother's HiFi setup, I sent off for a kit to build a graphic equaliser. I built it and it worked first time.

University Round One

I had enrolled in Engineering, for which the first year was common across the four disciplines then available - Civil, Mechanical, Electrical, Electronic. Yes, just those four. I have a memory that someone in my school had wanted to do some other kind of engineering, for which he would need to get into a university in Queensland.

Again, this is all so long ago that I don't have a clear memory of which part of my course had a unit for programming. So I don't have a narrative for this, just dot points of things that I can remember.

  • I remember we were taught FORTRAN IV - that being the language that engineers would use.
  • we used punched cards, but now had access to typewriter-style machines that would let us make the cards by pressing keys on a QWERTY keyboard. These were quite mechanical devices and it took quite a powerful push on a key to punch the card.
  • the down side of this was that a single bad type wrecked a whole card. We students quickly found ourselves having lots of messed up cards at our disposal.
  • with our card stacks punched out, we would walk around to the back alley where the access entrance was for the Western Australia Regional Computing Centre. This was where my cards from years earlier had been sent.
  • We'd put our stacks in a pigeon hole and would need to check each day to see if there was yet any printout in return. It was at this point that I found it was possible to have no output at all - just a slip saying exactly that.

  • post script - in looking for images for this context I found this page - UWA Computing History Highlights - which mentions the schools programme and probably (as MiniWaft rings a bell) means that the language we wrote in was FORTRAN. And there's even a picture of the back alley entrance.

  • WARCC entrance

I had friends who were doing Science courses rather than Engineering. Some of them were doing units of Computer Science. They got to use VDU terminals (visual display units) and work live on the timesharing system. Instead of printouts, their programs sent output directly to the screen in front of them. I don't remember much of what I saw them do, but it would have been my first witnessing of live use of a computer since the Wang all those years earlier.

I do recall getting the impression that these science students knew about other people with more power on the systems. That somehow, their use of a computer had a social aspect to it. By comparison, my programming world was just as impersonal as the high school situation had been. It seemed that to our engineering lecturers, the computing thing was just a tool, not something to be interested in for itself.

The one other programming story in these years was once again, about calculators. One of my college friends had a programmable HP calculator. This used RPN and could hold calculating sequences of up to about a hundred steps and even do loops in them. As I already knew about RPN, I helped him devise a program that would derive all the prime numbers in sequence.

To cut a long story short, I failed Round One of university and dropped out while doing second year Engineering.

Unemployed Round One

So I was unemployed for a while.

The Physics Department

During this period, I somehow managed to get some work at the university. My handiness with a soldering iron was of use to the Physics department and I got a temporary job in their tech support area. This area had two crews of experienced permanent employees - one part in a mechanical workshop and the other in an electronics workshop. I was soon making various custom circuits that one of the staff would design. At one point I was a one-man production line making multiple copies of a thousand-gain amplifier for the gravity wave project.

  • All this time later, it can be hard to pinpoint evidence for the early parts of the Gravity Waves project at UWA but the page at that link does include the following: "Professor Blair and his team started building a detector consisting of a huge bar of niobium at UWA in 1976 in the hope of detecting these waves." I never saw a bar of niobium but I do remember seeing the aging synchrotron in the basement amid racks of discarded NASA and US military electronic gear.

In my Engineering course, I had been learning the physics of semi-conductors, and the complex mathematics required to understand impedance in AC circuits. But it was in this workshop that I learned the point of continuity between an analogue circuit and a digital one. This is that both use the same signal response curve coming through the transistor. For the analogue circuit, the slope of the curve gets used as an amplifier; for the digital, it is the distinct endpoints of the curve that get used as levels for binary zero and one.

This might seem to have little to do with programming, but for me it was always something intrinsic as I began dealing with computers. Where that "something" was: that I had an expectation that I could understand it all, from silicon upwards.

  • Actually, my understanding often advanced with discontinuous jumps, and it would only be much later that I would explore the gap between transistors and built-in CPU instructions. I don't claim that understanding every layer and level of construction is important for a programmer - but it was always something that I wanted to have.

While I'm not sure why, the workshop had a few computers. At least one was a hand-me-down from somewhere in the department - that I think had needed repair but never went back out of the workshop.

Another computer was a fully functional Oki brand CP/M computer with a colour screen and a built-in dot matrix printer. It had a version of Microsoft Basic, that in retrospect must have been one of their custom versions as it included colour commands for the colour screen. In my breaks, I was free to use it.

  • for this my memory is clearer, right down to the exact model - OKI IF-800 / 30
  • OKI IF-800 / 30

Finally, I had a live computer to myself - I was OFF!

I was soon exploring how to write all kinds of number theory programs. Oddly I only distinctly remember writing programs for various sequences - Prime numbers, Perfect numbers, the Fibonacci sequence etc. However I do remember writing one that proved to be very unpredictable. This is notable now as being my first (if slight) brush with chaos mathematics.

My addiction to reading magazines took a turn as I avidly read the computer magazines that the Physics department supplied to its staff - notably Australian Personal Computer.

As you might expect, I was enjoying my work at the university. Alas, it was only a short-term unemployment assistance programme so it soon ended. I have a vague memory of sometime later bumping into one of the staff I'd worked with, who said that the next person they got through the scheme was so underwhelming that the department ceased its involvement.

Working for the Physics department may have been temporary and subsidised, but it was a real job, so I really did get paid. Even though I was back to being unemployed, and therefore back to living from payment to payment, I now had some money in my bank account.

What would I do with it? I remember considering whether or not to buy a car, though to be honest I had no particular use for one. But instead my magazine reading in the department had signalled a new possibility and with money to spend, my life was about to change direction.

For reader, I bought my first computer.

It was a Microbee 56k with a Z80 CPU and a dual floppy disk drive.

  • Images from Microbee - Old Models Gallery
  • the 56k model with disk drive unit (but not my monitor) the 56k with disk drive unit (but not my monitor)
  • the later 128k that I upgraded to, and showing the monitor type I already had the later 128k that I upgraded to, and showing the monitor type I already had

The how and why I bought quite what I did, would make this too tedious, but it does lead to an important change. This is because, by coincidence, the shop where I bought my computer was one street over from where I lived - and it was actually a retail outlet operated by the manufacturer. From hanging around there, in the shop, I would soon come to be employed by the company that made my computer.

This computer was CP/M based and came with its own rendition of Basic. I soon added to this by buying Microsoft Basic for CP/M. Later I added Turbo Pascal and later still a Modula-2 compiler.


More dot points:

  • games for the Microbee that weren't published by the manufacturer often went out of their way to be hard to copy. As media still weren't reliable many of us wanted to be able to copy them, literally as backups for our purchases.
  • in order to work this out, I taught myself Z80 "machine code" in raw hexadecimal.
  • I had a Z80 handbook and learned how all the "opcodes" worked. I still remember C3 xx xx and C9 xx xx as being the GOTO and GOSUB equivalents.
  • I never learned "Assembler", and never wrote any code to be assembled, nor used the supplied assembler program.
  • actually I soon ignored the issue of copying games and started using my new knowledge to work out how to change my computer.

The Microbee had its terminal handling as machine code burned into its ROM chip. This set the screen as 80x24 characters but I realised that 80x25 would still fit inside the amount of RAM dedicated to the screen mapping. Without disassembling I traced the code by reading it in hex and working what would need to be changed. Eventually I would borrow an EPROM burner and make the change permanent by swapping in my customised ROM.


I had a book about making indexes for handling data files and can remember working my way through writing various kinds of index files using Basic. I don't recall the boundary point about B-Tree indexes - whether I wrote my own or adapted code from elsewhere.

I bought my first modem - the new type was 1200/75 baud - and connected to some of the city's early bulletin boards - I was soon downloading various programs written in generic Basic as well as compiled utilities for the generic 8080 chip series.

Among these were "Hunt the Wumpus" and numerous variations of "Trek" games (Star Trek never quite being explicitly named). Often reading the code for these was as interesting as running them. Ditto for making changes to them as something to do and learn by doing.

I remember one Trek version was much larger that most but seem to have some obscure bugs. I became determined to fix it, and spent much time with printouts of the whole thing and draw coloured lines all over it trying literally to draw all the pathways. And no, I never did resolve its issues - but I do credit this with teaching me a lesson about code written with too many GOTO statements.

While I was working for Microbee and as they were keen to expand the range of software available I was asked to translate and localise a Basic program that someone in Sweden had written. Not having access to anything for understanding Swedish I needed to read the code to work out the meanings of display words that I would need to translate into English.

Something that I remember learning from this experience was the re-coder's dilemma: when doing some kind of wholesale change, do you also make fixes or improvements as you go along? Or is that a really bad idea? (Guess which I learned I there.) Perhaps this is where I acquired a habit of reading code and writing a separate set of notes about the code.

For that computer. the graphics options were quite limited. As a user, the only functions were in the platform-specific version of Basic - and this offered two modes:

  • a very low resolution mode, with some simple line and circle drawing commands.
  • a high resolution mode, but which had a quirk - it would run out of ability to draw at a hard-to-guess point of complexity.

The limitation was due to the display being character mapped, not bitmapped. The ability to do graphics at all was because the second half of the 8-bit character set was handled in RAM. For the low resolution it created a subset of characters that covered all possible permutations of a small grid inside the character bitmap. For the high resolution, it would create whatever characters it would need as it went along - but just stopped when it has used up all 128 of them. This mode was also quite slow, as the background logic had a lot to do.

As a result, apart from designing customer characters and fonts for my programs, I did almost no "graphics" coding at all.

While I do recall doing various amounts of more serious programming - reading and writing and organising data - I don't have clear memories of doing that in Basic because I quickly shifted all my coding once I bought Turbo Pascal.

Turbo Pascal

I was aware of Turbo Pascal version 2 from selling it in the shop. The impetus for me to buy a copy - which by then was version 3 - came instead from many conversations I had with a housemate. As a meteorologist he had a triple major degree - mathematics, physics and computer science - and it was due to the latter that we had many discussions about the concepts of programming.

I was reading in my computer magazines about the revolutionary nature of Turbo Pascal - by being much more affordable and yet also much better than the existing Pascal compilers. Between that and my housemate's descriptions of the Pascal and Modula-2 languages, I bought my first compiler.

This was the second lightning bolt. It was just amazing. Now I could make my own utility programs that could be runnable from CP/M just like any program.

Using Pascal changed my whole perspective about programming. I sought to understand what the compiler would interpret and do with my code. I took much more notice of what I named elements in the program. I started thinking about programming as a combination of both design and execution.

I wrote a number of multidimensional games (long story). And if I needed a program to do something, I would just write one.

dBase II

While I was working for Microbee, I had various roles. Officially I was doing sales and repair, but I also did some teaching, promotions, and liaising with the local users group.

Within the store we used a custom program for managing the till (i.e. recording sales and printing receipts). In the backroom we used a copy of dBase II for managing the inventory. I was soon drafted into learning enough about dBase II to keep that setup going.

Back then dBase was the dominant product in the CP/M market. It quickly became the same in the MS-DOS era but eventually failed to keep itself as dominant. See the Wikipedia pages for its history. You'll barely see CP/M mentioned there as that was the smaller scale stage of its course.

To be clear, dBase II managed each table as a file. Each index was yet another file. It had its own language for manipulating the tables and having memory variables (like a programming language). It was not relational, there was no SQL involved. But it was a step up from having custom programs written completely in a programming language - and thereby possibly using custom ways of storing data in files.

It was not unusual for its index files to become corrupted and the reality of me "working" with it was largely me using its instructions to destroy and rebuild its indexes.

  • Regardng "corrupted" - to cut a long story short, it's hard now to describe the unreliability of computer hardware of that time. By just ten years later the hassles and failures were largely just a memory.


As it happened, I did have some intersection with relational databases in this era. My memory is a bit muddled about this, so I may have the details mixed.

Part of my job was promotional - the company would book space and set up a stand at various exhibitions and "shows".

  • Microbee stand at Computer show in the since demolished Entertainment Centre Microbee stand at Computer show
  • Microbee stand at Consumer Electronics Show in Claremont Microbee stand at CES

In particular, we also went to "country shows" around the south west of Western Australia, for which, as a product to help sell the computers, we would demonstrate a farm management software package. I don't recall its exact name but it was probably just something like "FarmBase".

What I don't recall now is whether this "FarmBase" was built using Sybase, or whether Sybase was yet another product that we sold.

I do remember that Sybase was "relational". I didn't really know what that meant. One of the part-time staff at the company was studying relational databases at university and tried explaining the concepts to me. That didn't really work, and all I distinctly remember was him saying that unlike dBase, the product "DataFlex" (which we didn't sell) was really relational.

Considering a return to study

I will have to guess that it was around this time that I'd saved up enough money for another attempt at university study. I told my employer that I was thinking of applying to get a place the next year. They responded by sacking me. So that was nice (yes, that's sarcasm).

Now with nothing to lose, I duly applied to two universities and had a while to wait to find out if I would get in. Technically this meant I was unemployed again for a few months - but we won't count it as such for this story.

Concept discussions

I've mentioned that during this period I had many conversations about programming concepts with a meteorologist co-tenant. I think it was from his suggestion that I bought three university text books by J S Rohl which used Pascal as the learning language.

Between the books and our conversations I :

  • came to understand recursion.
  • discussed functional programming, notably Lisp.
  • discussed co-processing, notably with the idea of co-routines in Modula-2.
  • gained a concept that I've since kept in mind as "zero one infinity" (see below).


Needless to say, for someone whose haphazard learning had just been about programs as sequences of actions with loops and jumps, discovering recursion was an epiphany.

I particularly remember where the Rohl book about recursion gave an implementation of the Ackermann function and this led to many discussions about number theory and Turing machines.

I was fascinated by the three great recursive sorting algorithms, Merge-sort, Heap-sort and Quick-sort and I suspect it was during discussions about these that I first heard about Knuth's The Art of Computer Programming.

Zero One Infinity

This idea came about because I was musing about how to write an operating system for the Microbee, which used RAM bank switching to operate 128k of RAM on an 8 bit computer (8 bits can only address 64k). While to me that meant the OS would need to very much have a concept of this-or-that as a basis, my housemate's view was that it would be silly to bake two-ness into the very operating system. I don't now recall whether it was he or I that distilled that into what I have kept as a "zero one infinity" rule.

Put simply, the concept is that in computing there are only three special numbers:

  • zero - for when something doesn't exist or never happens
  • one - for when something is unique
  • infinity - for everything else (memory or storage permitting).

By this concept, the use of any other number is distinctly arbitrary and therefore should never be baked in or hard coded. At the least, when pragmatism requires using some value, it should be set in the code as a named constant so that its inherent arbitrariness is also apparent (and/or can be later replaced by a variable or a function).


Somewhere in all that period I read the book - Gödel, Escher, Bach: an Eternal Golden Braid, by Douglas Hofstadter. It's hard to be sure quite when I got it - I still have my copy which is from a 1982 print run. I remember it took me most of a year to read and fully grasp it all.

It is hard to be specific how this affected my conceptualising of programming, but it certainly did. At the least, it introduced me to the field of A.I. (as much as I dislike than name) and that became another vector for my reading for many years.


University Round 2

Luckily I was offered a place as a "mature age" student, which just meant that I wasn't going straight from high school. Less luckily it was to a different university and they wouldn't recognise my previous Engineering study at the other one. So, I would be a "first year" student once again. Also, I had scraped in by being offered a non-standard course of "Multidisciplinary Science", which meant I could choose my own subjects. In retrospect I wonder if they had some places set aside for people needing strange combinations of course units. I was just glad to have a place. Besides, this time I could include a bone fide programming unit.

Alas, I don't have much else to say about that year. Or conversely I could say way too much.

Some good things:

  • I did a real statistics unit - and thus got a good grounding in that subject.
  • I did a combinatorial mathematics unit - ditto.
  • I did an "Engineering" unit that turned out to involve writing:
    • programs in Fortran 77 - hailed by the lecturer as the "new Fortran" (yes, 77 refers to 1977)
    • programs for the PDP8 - emulated on a Macintosh (yes the very first types with the tiny screens).
  • I did a programming unit, that involved Pascal.

The statistics and the combinatorics have remained useful for my entire eventual career. From the Pascal course I learned about "asserts" and the idea of provably correct programs.

The bad thing:

  • I was still a really lousy student. I'd have a write a whole other essay to cover this, but the short version is that even in this late stage I was still doing "learning" as if the aim was for me to fully understand things. It was only much later that I realised nobody in their right mind tackles "education" that way. The sensible way to tackle full time education is that you do courses in order to pass them. Learning is optional.
  • Even worse, I learned that in academic courses, successful programming is only about writing what's expected.

The latter point comes from the fact that I just scraped along in my units, but failed my programming exam. As a matter of pragmatism, I had to look at my finances and make a judgment. For the second time in my life, I couldn't risk my remaining money on a chance of failing and so, chose to withdraw from the second semester. Just like that, I was unemployed again.

Unemployment Round 2

The unemployment aspect of this is easy to summarise:

  • I dropped out of university mid 1986
  • Unemployment was high
  • I sat a clerical entrance test for joining the public service
  • Then in late 1988 I got an offer from the public service and began work again in early 1989.

In the meantime - for the purpose of this story - I did two things:

  • I read voraciously in the university and state libraries.
  • I wrote a lot of Pascal programs

I think it was in this period that I also bought a Modula-2 compiler - FTL Modula-2 - but the reality is that I didn't make anything useful with it.

One thing I should say about this period is that in having no spare money, I just kept using my Microbee computers - having upgraded one and then buying a spare during my company years. All the computer magazines I read - at the libraries - told me about the 16-bit world that overtook my computers. So I had awareness of MS-DOS, but no experience outside my archaic little home bubble.

It's hard to work out how much of the things I recall writing in Turbo Pascal belong to this period or were done earlier. For example, at some point I wrote a "windowing" GUI interface system for the memory-mapped screen of the Microbee. I toyed with designs for a whole operating system. There's quite a mix of things I actually wrote back then, along with things I only sketched ideas for, but that would later be drawn upon in various realms of coding and data.

Among the quirky things that I remember reading in this period are:

  • the origins and process by which the ASCII set was settled upon
  • lots of opinions about programming and operating systems from people like Edsger Dijkstra
  • books covering the history and concepts of operating systems
  • books covering the history and concepts of databases
  • functional programming - I remember getting a CP/M version of Prolog and playing with that.
  • some volumes of "The Art of Computer Programming".

In many ways, this was actually my most academic period in which I learned the most theory, much of which I have carried with me for evermore.

The Amiga

Something else that happened during this waiting period was that the meteorologist in the house bought himself an Amiga 1000 (i.e. the first one). He generously let me muck about with it. I made my own copies of the system floppies - the Amiga 1000 had no internal hard drive - so everything I did was its own little world.

My memories of this are now quite vague. I know a played around with several programming languages on it, but have no recollection of writing anything distinct. I remember that I looked at a lot of software on it that had come from "online" but I have no recollection of by what means.

An important thing though is that it was with this Amiga that my understanding of Free Software crystallised.

Software Freedom in the 1980s

I've mentioned having much earlier been a user of bulletin boards with my CP/M computer. It would have been there that I first saw various approaches to software licensing, notably as some software tools had been ported to CP/M from the world of Unix and other operating systems. While I can't find any evidence now, I do think I first saw mention of software freedom that way.

I also would have read about the GNU project and then the Free Software Foundation in computer magazines, so I would have had a fair awareness of the concepts and goals of this new movement.

But it would have been on the Amiga that I probably first saw software literally quoting itself as "free" and seeing the GPL in the annotations. I distinctly recall seeing a Gnu Emacs version there for example.

I don't recall having any thoughts to put a license statement into my own programs - but then I wasn't writing for distribution to anyone else, so there was probably no prompt for that idea anyway.

The Next Chapter

As noted already, in 1989 all things would change, with a new job - and although I didn't know it, a new career.

Top comments (1)

geraldew profile image

As you might guess, the story continues in My Coding History - Part 2