A lesson in life

It’s been over 25 years since I finished my undergrad B.Sc. I went to university because my parents wanted me to go. I would have been just as happy becoming a carpenter, building things. I chose a university in the middle of nowhere in Australia, and never visited it before the day I started there. I was forbidden to become an architect, which is what I would have likely enjoyed doing, because my father was a draftsman. He disliked architects, to put it mildly. Initially I got accepted at the university to do agriculture (which *nobody* had an issue with, when you think about it is kind-of bizarre). I guess I never really put a lot of effort into choosing a university course because my heart really wasn’t in it. I changed to science before I had even chosen classes. In my first year I took biomath (i.e. math for biologists), chemistry (which I loathed), biology, and computer science. Biology seemed like a good choice, and some of the zoological stuff seemed kinda interesting (i.e. insects), but the botany part was dead boring, and overall it involved far too much rote learning, which I’m hopeless at. I had bad experiences with chemistry in high school, and never thought I would have to see it again – I was wrong, and ended up taking it for a second time in 2nd year. Math, well it was okay, half statistics, and next to no calculus.

The odd-ball course was computer science – I had never written a program in my life. Sure, we had an Apple IIe at home, but all I did on that was write BASIC “programs” with PRINT statements to print out essays, because I didn’t have a word processor. So I took the introductory course and learnt Pascal. Turns out programming was one of the few things that I was adept at, probably because it required you to build things. There were aspects that didn’t really interest me – theoretical stuff, hardware, assembler. But programming was fun. In the late 1980s programming was Pascal, C, Cobol, Fortran, and maybe Ada. And one of the shell languages. I took a “software engineering” course in my last year, but dropped it because I really felt it was lots of “mumbo-jumbo”. This was an early rendition of software engineering in a beginning of the era of OO. In the late 80s there was very little in the way of “software” type courses – everything was focused on programming. There were no group projects, or even larger-scale projects – and no design documents. Ironically I went on to get more degrees in computer science – because life lead me in that direction. I still enjoy programming immensely, learning new languages, and “building” software. As an undergrad I ended up taking 10 CS courses (that’s all there was).

First Year
Introduction to Programming I (Pascal)
Introduction to Programming II (Pascal)

Second Year
Unix and C
Computer Architecture & Assembler
Cobol & Introduction to Databases
Data Structures

Third Year
Compilers and Grammars
Comparative Study of Languages
Advanced Databases
An Introduction to Parallel Processing

In addition I took a numerical math and a computational math course involving Fortran.

My honours thesis (a separate 1-year degree in the British system) was on object-oriented problem solving in C++. By the end of my undergraduate degree I could program in Pascal, C, C++, Fortran, Ada, Cobol, and a bunch of shell scripting. I dabbled in some Prolog and Lisp, but never really found a passion for them as languages. Most of the work as undergrads was done on Unix systems, on the command-line. Few relevant compilers were available for DOS/Windows – these machines were still only bootable via a 5-1/4” floppy disk.

I learnt more in my first job, working in the Cartographic Services Unit of the Australian Geological Survey Organisation. They made maps, on huge Unix-based CAD machines, and PCs. GIS was just coming into the fray. Some of the other equipment was *old*. PDP-11 machines that had to boot off two magnetic tapes, and had monster 20MB disks attached. Huge drum scanners and plotters, that would produce maps. Networking, but no internet as we know it today. Here was where the practical stuff was learnt – rebuilding PC’s getting networks to work, playing around with configuration files, and drivers for idiosyncratic pieces of add-on boards.

25 years later, machines are still machines, and programs are still being written in languages such as C, Fortran, C++ and Cobol. Machines are faster and smaller, programming languages are more complex, software is ballooning in size, and design has become far too complicated. But at the end of the day we are still writing programs to solve problems.


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.