Coding: a not-so-brief history
Since it seems that February is “interests month” on the blog, I figured I’d continue the trend and write about an interest that has been with me since the very beginning, and that currently forms a large part of my life. That interest is computers and programming. Disclaimer: This is going to be a very long, nerdy post. Most of it will probably be gibberish if you don’t know much about programming. You have been warned.
From a very young age, my family has owned computers. There is a photo of me at about 2-3 years of age grasping a joystick and playing Jet Set Willy on an AMSTRAD CPC 6128. While I don’t have the actual photo, here’s what such an AMSTRAD looks like:
This particular AMSTRAD came with a few floppy disks with programs and games on them, and a book. The computer was programmed using a stripped down version of BASIC, and the book contained a bunch of example programs, often many pages long. I learnt to type pretty quickly with two fingers, as I would laboriously type out these big long programs. Often one mistake would result in them not working properly (or not at all), but there was always a certain sense of satisfaction (and fascination) when the computer would spring into life and actually do something based on what I had just typed in. My interest was piqued.
After a few years, the old AMSTRAD gave up and died, and we got a 386DX PC as a replacement (loaded up with the shiny new Windows 3.11). After a frustrating few days trying to enter BASIC commands from the AMSTRAD book at a DOS command prompt, I decided to talk to my uncle, who was in the PC business (and built the 386 for us). He installed QBASIC for me and showed me how to use it. I quickly discovered that the AMSTRAD programs didn’t work so well in QBASIC, and so a visit to the library later, I was teaching myself QBASIC. My first programs were pretty basic, doing things involving displaying text output and taking text input. I can recall a “math quiz” program that generated random math problems and tested for the correct result.
QBASIC was my staple programming language for the better part of 5 years (I would estimate from the ages of 7-12), and after a while I got fairly proficient at it, creating applications with “rich” (at the time) graphics and sound. However, I was inevitably getting a bit sick of it, and my interest in creating QBASIC applications was quickly tailing off. It was about this time that we got a flash new computer – a Pentium 200MHz with Windows 95.
It was at the age of 12 that I then discovered Visual Basic on one of the computers at school. Here was a language that let me apply my BASIC knowledge to creating pretty rich Windows applications in an astonishingly straightforward way. A bit of begging and pleading later, I managed to score myself Visual Basic 6 on my 13th birthday (sad, I know). My interest was once again piqued.
What followed was a raft of fairly complex (if I may say so myself) applications, such as a timesheet application that I used to record my lawnmowing/carwashing/chores hours to charge my parents, an MP3 file renamer, a digital camera synchronisation tool, and a prime number finder. I even made a nifty little application for my Dad that would recognise when ArchiCAD (drafting software he used for work) was running and in focus, and record for how long. He used this for a couple of years to record his working hours when working from home.
Of course, with my ear to the ground, it didn’t take me long to work out that Visual Basic wasn’t the be all and end all of programming languages (in fact, quite the opposite – it’s in many ways the ugly cousin of “true” languages). I kept hearing about this amazing language known as C++. And so when I was about 15 (I think it was for my birthday again), I became the proud owner of a pretty thick book about C++, covering everything from the basics, to pointers and multiple inheritance. For a time I was a little discouraged, as C++ lacked the “glitz and glam” of VB6 (the book only covered writing console applications and the features of the language – in retrospect the right way to learn), as even after 6 months or so I was still writing applications that made text output and took text input. In some ways it was like going back to QBASIC.
After a time I discovered the Win32 API, and how to create a window and make a message queue and so on. After a couple days visiting a local game development studio, I was inspired to create some little graphical applications, such as a 2D particle system and a “starfield” animation, using C++ and Win32. I never totally got into it, though. I hadn’t discovered MFC at the time, and Win32 was a major pain in the ass to write. The peak of my C++ coding was a little 3D game that I made after discovering the DirectX Software Development Kit (SDK). The language always struck me as pretty ugly (especially with the horrendous Hungarian naming that all the Win32 libraries used), and I longed to return to a language that had sensible naming and no preprocessor directives. In my reading about the DirectX SDK, I discovered a newly emerging language: VB.NET. I was about 17 at the time.
I set about translating my C++ 3D game into VB.NET. By the time I had it working (a surprisingly simple process), I was sold. .NET let me take the good bits of VB6 (simple window creation, sensible naming, etc), and combine them with a fast, robust, non-scripted language. Naturally, it wasn’t long before I moved in turn to C#, which continues to be my preferred language to date.
From about the age of 15, I knew that I wanted to turn my interest into a job. It made sense – I enjoyed doing it, why not get paid to do it? And so I decided to go into a Software Engineering degree after high school. At university, the first language we were taught was Java (where my C++/C# knowledge meant that I already knew everything I needed to know). I went drinking the night before the final exam, finished the 3-hour exam after an hour, was first to leave, and still managed to get an A+. Score. After that, we were taught a variety of other languages, including C (again, C++ came in handy), Tcl/Tk, and Lisp. Fortunately things got a little more challenging in 3rd and 4th year, and I was actually learning things about programming again.
I’m not really sure how to finish this post (as my interest is very much an ongoing thing), so to sum it up: I’ve been cultivating a passion for computers and programming from a young age, and I now get paid to do what I love; Code.
This entry was posted on Wednesday, February 17th, 2010 at 10:19 am and is filed under Code, Life. You can follow any responses to this entry through the RSS 2.0 feed. You can skip to the end and leave a response. Pinging is currently not allowed.