My journey into programming
Today I work with 🧪 Elixir and Phoenix as a lead developer for Copia Wealth Studios. I’m also the author of Get Programming with Go, which was published in 2018.
What follows is my personal account of becoming a programmer and my career.
Childhood
I grew up on Lego, Dr. Seuss, and Berenstain Bears in a tiny Alberta village. After my parents divorce, an Atari Computer found its way into our home. As far as I knew, its sole purpose was to play video games. 🕹
Then one day the school library held a book fair where I found a colourful book filled with short BASIC programs. I don’t recall the title, but it was likely one of the books published by Usborne.
When my Dad saw my interest, he gave me a coil-bound manual for BASIC and let me use his Kaypro IV on the weekends. It came with several games, including interactive fiction like Colossal Cave and Hitchhiker’s Guide to the Galaxy, some of which were distributed with BASIC source code.
The first computer I owned was a Commodore 16 from a garage sale, tape drive and all! I wrote a historic text adventure where your character wandered Israel in search of Jesus. It wasn’t sophisticated or well-researched, but one of my first computer projects.
Youth
By junior high, our school upgraded the lab from Apple IIs to amber-screened XTs. Thankfully there was one computer with a colour screen, plus our neighbours let me use their PC after school. Progressing from GW-BASIC to QBasic, I wrote my own remakes of Star Traders and Atlantis.
In addition to lawn-mowing income, I earned money tutoring people with computers. When I had enough saved, I went to Programmers Guild to buy Turbo C 2.0. Unfortunately Turbo C wasn’t the most approachable:
- A simple syntax error would dump a dozen seemingly unrelated errors.
- I found the IDE confusing, the keys reminded me of WordStar!
QuickBASIC 4.5 turned out to be a much better investment.
While in Grade 9, my Mom helped me pay for a correspondence course from NRI (McGraw-Hill Education). The three-year course covered computer programming in five languages and came with a 386 SX.
Resolved in my future career path, I wrote a letter to Nintendo and received a genuine response encouraging me in my studies to become a programmer.
So, inspired by Galaga and other SHMUPs, my brother and I set out to make Firebirds. It had timing issues on faster computers and the “scrolling” and collision system were amateurish. While not exactly Raptor, it was a complete game, with title screens, difficulty levels, 2-players, sound effects, and both mouse and keyboard control. We distributed it through local Bulletin Board Systems (BBS).
My high school needed an application to do timed typing tests, so I wrote one. The first version of Trial Type was a DOS application written in QuickBasic. I registered Lynx Software as a sole proprietorship and licensed the software to a number of schools.
QuickBasic also allowed me to build a custom database for an alarm installation company. I was proud of the text-based UI, but unfortunately I knew nothing of B-trees. It got slow with a lot of data.
Eventually I gave Turbo C another try, using DOS edit and the command-line compiler instead of that unintuitive IDE. Later, Borland C++ allowed me to make a Windows version of Trial Type and the far less successful Graphematics graphing calculator.
Apps were making me money, but I still really wanted to make games. By now I was using C and Assembler and experimenting with Mode X, VESA and EMS/XMS memory. 640K really wasn’t enough. I bought Watcom C/C++ so I could use DOS4GW. It was wondrous!
The Internet turned out to be quite useful. I was able to assemble a team of artists to work on a real-time strategy game entitled Galaxy. We got a prototype up and running, but it lost momentum. The rise of DirectX brought the question of whether to continue or switch technologies. In the end, the prototype was as far as we got.
Early Career
At that time the web was still relatively new. I remember reading the HTML 2.0 specification, one of the few resources available to learn it.
It wasn’t long before I wrote a command-line tool to make HTML easier to work with. HyperProcess was a cross-platform preprocessor for HTML written in C. It supported file includes and other features, while also serving to lint and minify my HTML. Think static-site generator sans-Markdown, or Jamstack before the rise of JavaScript and RESTful APIs.
HyperProcess came in handy at my first web development job, but at my next job I discovered Server Side Includes and eventually ColdFusion. By the turn of the century, familiarity with SQL, ColdFusion, and JavaScript made for a platform where I could do real programming. I stuck with ColdFusion for eight years across three jobs.
Though I didn’t know it at the time, ColdFusion, Java, JavaScript, PHP, and Ruby were all released in 1995, the same year I graduated High School. Impeccable timing for a budding web developer.
All Aboard
I was on sabbatical in Europe when I first heard of a certain new web framework. Ruby on Rails enticed me with its ORM and organized file layout. To top it off, my Dad worked for 🛤 CN when I was young, so even the name Rails was appealing.
After returning from Bible school to celebrate Christmas, I found a copy of Agile Web Development with Rails (Pragmatic Bookshelf, 2005) at the local computer bookstore. I did some freelancing until I was hired by a Christian non-profit to build an app with Ruby on Rails. Thus I transitioned my career, with Ruby becoming my primary language for the next eight years, across another three jobs.
Scaling Up
When Google introduced the Go Programming language in 2009, I watched the video and tried it out, but I didn’t dig in. Then in 2011, inspired by a colleague’s experience, I read the rough cut of The Go Programming Language Phrasebook (Addison-Wesley Professional, 2012) over a Christmas break.
The following summer I was between jobs with time on my hands. One of my experiments was a Go binding for OpenGL 3.2 Core Profile, which I called Mantle (this was a year before AMD released their low-overhead API of the same name, no relation). It was fun playing with a C-like language again.
That year I landed a job at an early-stage startup, becoming one of the first employees. We were building a Ruby on Rails app and deploying it to Heroku, but scaling was expensive. We upgraded our application server to Unicorn, which uses a process model. The application consumed ~300MB of memory, so one Heroku dyno (1GB) could handle 3 simultaneous requests. Better than only one, but still not great. Eventually I moved the app to Puma, which helped improve matters, but I knew Go would be much more efficient.
Go, APIs, and microservices were all the hype, but the monolith at work just grew bigger and bigger. While I couldn’t use Go at work, I did invest my own time into open source projects and started the Edmonton Go meetup in 2014.
Later that year I took a second job, working a few hours a week as a contractor for a 🦊 small consulting company. My task was to transition performance-sensitive functionality from Ruby to Go, interacting with Ruby through JSON APIs, message queues like Sidekiq, or Redis pub/sub. Projects included Apple push notifications (open source), streaming file uploads to S3, and a websockets proxy.
Then we discovered 🧪 Elixir and Phoenix. Built on Erlang/OTP, it promised concurrency and efficiency similar to Go, while Phoenix and Ecto provided the niceties of Ruby on Rails. I wasn’t sold at first, having come to appreciate Go’s simplicity, static type checking, and fast compiler. Still, I enjoy learning, so learn I did.
Next Gen
When I began my career, I didn’t know the web would become an open platform for building apps, or that the SaaS model would become a dominate way to distribute software. I fell into web development, and I’m really glad I did!
As I reminisce of the people and authors who got me to where I am, I think about the next generation of web developers.
Get Programming with Go (Manning Publications, 2018) is my first technical book, a beginner’s guide to the Go programming language, focused on the language itself.
Through writing, mentoring, and other efforts to share what we learn, we can empower the next generation of developers!
Related: