1. In 1984 my employer Data General introduced a relational database and a Common Lisp compiler.
2. In 1986 I joined Boeing and spent almost all my time programming Symbolics Lisp Machines and Tektronix 4400 Smalltalk machines.
3. Also in 1986 I began using KnowledgeCraft, a forerunner of today’s Semantic Web / graph database tools.
4. In 1987 I started using the GemStone Smalltalk OODB / application server.
5. Around 2000 or so I started using Jini / JavaSpaces, which is to distributed and concurrent systems what Smalltalk is to application programming.

Unix

Before discovering and learning Unix, my computing life was either DOS or terrible GUIs. Unix changed everything I thought about computing.

Perl

The first language I was truly fluent in and able to just reach for in (almost) any situation was Perl. I never code in this anymore, but it will always have prominent place in my version of history.

Version control

Right back to CVS, through SVN, and now ultimately to Git, version control makes programming possible. Maintaining multiple copies of files with filenames structured with dates and typing version numbers by hand into files was always a major obstacle to rapid (or not rapid) iteration.

Virtualization

Included in this is all forms of virtualization; VM, container, even good ol' games emulation, etc. The ability to mimic a second system, alternate architecture, spin up a lab environment, etc, has been essential to being able to experiment freely.

Ethereal (Wireshark) changed the way a lot of us network hardware / protocol / security people worked. It used to be that if your company could afford to buy a packet capture and decode device, it was a shared hardware resource, and it certainly couldn’t decode any new or proprietary protocols that were under development. After Ethereal, anyone with a workstation could capture and decode packet streams.

I wrote the original PPPoE decoders for Ethereal in 1999 when there were less than 20 of us working on the project. I ended up writing several other proprietary protocol decoder modules for various companies over the years.

Working on Ethereal definitely changed my career for the better.

• ~19 years ago (ouch). When I first cracked open VBA and wrote my own formula for excel. This started me down the path of using code to solve problems more easily.
• ~15 years ago. When I first really understood SQL and operating on sets.
• ~11 years ago. Unix. This was a dramatic break from my life and changed how I think little by little
• ~11 years ago. Ruby. My third language, my first interpreted language. I started to think differently and understand solutions differently.
• ~10 years ago VIM. This is where I really started to understand how to use and customize my tools.
• ~10 years ago git. This was something that seemed so obvious after I did it but again I had to buy a book to understand it but now it is part of the tools that I use every day.
• ~2 years ago. I got a job on a distributed team. I think up until this time I had pretty much been a solo developer. While not a language or a tool, it has changed me and I think for the better.
• ~1 year ago. Elixir but really OTP. I am still riding this wave, but this has changed everything in ways that I haven’t seen since I moved out of Microsoft and onto Ruby. It was a humbling day when I realized that I had been trying very hard to build a system that was in fact just a not-so-good imitation of OTP.

13 years ago: C++. I was a freshman CS major. “Intro to CS” was in C++. This literally changed my career – I changed majors because I hated it so much. (Although, this was less about C++ itself and more the whole learning environment.) (And I kept programming games and websites for fun.)

3 years ago: Haskell. I’d decided to go back to school (a local community college) for programming just because after 10 years of searching, it turned out I wasn’t good at anything else. I was learning Java, but it was just about trying to get a piece of paper to get a job. Then I found out about Haskell somehow and got into this whole other world.

A few short years ago: Emacs. It introduced me to the love of my life: Lisp.

Also, maybe a bit surprising to some: JavaScript. Getting a job writing JS set me up to get a couple other jobs, and I’ve made a lot of great friends through those experiences. Not to mention that JS also introduced me to FP and subsequently Clojure(Script) and a wider world of programming languages.

When I was little I would play around with batch files and “toy” languages. Eventually I discovered PHP and it sent me spiralling into a love for code. PHP showed me how easy it was to create and the depth of the language, even back in the early 2000s, proved that while I was making basic calculators I could eventually use it to write whole complex websites and applications. I got many jobs as a result, and it was the beginning of where I am today.

C, especially working with sockets, pointers, and low level memory finagling, got me excited again many years later and put “the kernel” and low level operations within reach. I pretty much only used C in college but it was great and I’m still fond of it today for being such a raw language.

Python, and advanced libraries like Django (I know it’s a framework, I’m sorry), changed how I look at problem solving and made no problem too small to deserve a properly implemented solution.

Also vim and tmux totally changed my workflow and made appreciate keyboard interaction. I used tmux and i3 as daily drivers at a previous job and felt most at home.

• 1997: accidentally stumbled upon QBASIC.EXE while trying every executable in C:\DOS to see what they did. Started to learn to program, first using QBasic, then Visual Basic.
• 2002: found John Goerzen’s Linux Programming Bible at a cheap book sale. Was introduced to Linux, C, makefiles, network programming.
• 2004: grabbed a PHP and MySQL book from a shop when I was out in the city one day (might have been Larry Ullman’s PHP and MySQL for Dynamic Web Sites?). Began to make atrociously insecure web applications.
• 2008: GitHub beta; began using Git that over Subversion.

In general it wasn’t the technologies themselves that changed my career so much as the concepts and ideas they opened up to me, beginning with programming itself, and then areas of interest — systems, web, VCS — that culminated in me working in the intersection of all three.

I’d love to hear more about how Reflex changed your career so much.

1. c.1992: I discovered QBasic.exe when I ran out of things to do on my computer, and starting playing with GORILLA.BAS.
2. c. 1994: I got ZZT, and started making games in it.
3. 1996: a teacher gave me a boxed copy(!) of Borland Turbo C++. This led me to learn about C++ and C, and I bought The C Programming Language. Never actually learned C++.
4. 1997: I got the Internet, and started playing MUDs and MOOs. MUDs helped me learn more C, and MOOs taught me more about OO.
5. 2000: I learned Perl. A dark day.
6. 2003: I learned PHP. A darker day.
7. 2004: I learned Python, but didn’t take it very seriously. It would later become my primary language.
8. 2011: I took a graduate-level database management class, which is the turning point of my career: before this, I’d worked as a general web-wrangler, slinging PHP, JavaScript, and a few mediocre things that I could do with databases. The class made me realize: I get this. I should do more advanced things.

After that, most of my learning has been self-directed; I haven’t met something that completely takes me aback and makes me change direction. I’ve learned the functional paradigm, done a lot of reading in types, learned more about algorithms and distributed systems… but nothing has felt like it cast as long a shadow as the events above.

1) Behavior-driven development. Organizing interactions as tuples of

(setup_necessary_state(), 
 execute_action_under_test(), 
 verify_result()) 

changed the way I view system testing and design.

2) Remote pair-programming using tmux.

3) Types-as-design-drivers and types-as-documentation (Haskell).

4) Being able to rely on the runtime for debugging, introspection and resilience (Erlang/OTP).

Interesting question and to reflect on major events. I’m substituting ‘career’ with ‘life experience with programming’. These probably aren’t the things people are expecting, but stick out as inflection points:

• 6502 Assembler on a BBC B. < 10 years old feeling like I could touch what was happening in silicon, and getting a real understanding for what was happening at the lowest layers inside a PC. Fundamentally shaping experience for rest of my career, knowing what was happening in hardware.
• C (on Amiga). Browsing the standard libraries, understanding much bigger software architecture and looking inside stuff at OS level.
• MS Access & Jet. Introduction to RDBMS’s. The visual query builder in Access which could swap between GUI and SQL view was light years ahead. Learned relational data here, and was relieved later to find all the stuff I thought I shoudl have been able to do in Jet I could do in MSSQL or MySQL.
• PHP3 completely changed my career, suddenly a whole world of work opened up that wasn’t there before and a completely different way of interacting with code - online, collaborative, immediately deployment to user, etc.
• Zend Studio - an IDE with debugging. BIt late to this party.
• (wavey lines, transition to many years later). Java + IntelliJ Idea. Completely different world, static typing, IDE that seems to know what you’re thinking half the time, proper debugging, IDE integration with vcs, etc.

(Interesting that I haven’t had any major events in the past ~10 years or so, hmm!)

1990s:

1. Home computers + BASIC. Blew my mind. Made me a computer junkie. Perhaps the only thing that actually moulded me.
2. IBM PC + Pascal. First programming in school
3. MATLAB. My first scientific programming. My first graphical programming (via simulink)
4. Visual Basic, Visual C++. My first exposure to IDEs (Though that may be MATLAB too), compilation, OOP 4.5 Hand programming the 8085! Very proud when I wrote a long division program.
5. Multi user computing. Don’t switch off the machine, otherwise a very angry dude from the fourth floor will come for you and ask why you killed his process.
6. OpenGL!!!!!!!!!!
7. Machine Learning! Speech recognition!

2000s

1. Python! Move over MATLAB, it was good while it lasted, but your license server was a deal breaker. And the semicolons, and …
2. RAILS!
3. Databases!

2010s

1. Docker
2. Python3 + multiprocessing
3. LISP!

Sorry, this turned more into a personal journey than a list of tech. But it was fun to create this list, so I’ll leave it :) Also reminded me I’m starting to stagnate. Time to crank up the knowledge vacuum.

• Vim
  • My first “advanced” editor. Although now I use Emacs.
• JavaScript
  • This is my main money-making skillset. The ability to build for such a wide variety of platforms isn’t offered by other languages.
• Haskell
  • Heavily influenced the way I write code especially around how much I can reduce the complexity.
• Docker
  • Hard to exclude this from the list if only because I worked there for ~2 years. It also provided jumping off points to expand my knowledge in networking, dist-sys, linux, seccomp, etc and has changed how I think about deploying.

1995: Windows 95. Got me into GUI programming.

1996: Borland Delphi 2. Made the former enjoyable.

1997: First home install of Linux. As a Finn, this was cool. Think it was Red Hat 5 or something.

1999: SourceForge. “What’s open source?”

1999: PHP. Hey, web apps!

2000: SVN. CVS with better commits.

2002: .NET Framework. Fun GUI programming.

2005: Ruby on Rails. Web development got really fun.

2005: Git & Mercurial. Distributed SVN!

2005: Vim & Emacs. “Check this cool trick out!” fumbles with keyboard “shit, that wasn’t… wait…” fumbling continues forever

2007: Haskell. What the hell is a monad?

2008: Scala. Java with monads!

2008: Clojure. So many parentheses…

2009: Go. I still don’t know why I liked it, but I ended up coding it professionally for three years.

2009: NodeJS hey guys heard of event loops

2013: Rust I am not good with programming.

Of course, you could consider 1988 a relevant year, when the biggest tool of all eternity, I, was born.

Interesting question! Not all of them are development or even tools related, but they still influenced me heavily.

For me:

1. 1990: Learning to program in Turbo Pascal and later x86 assembly language. I haven’t used either in almost 20 years but they laid the foundation for all that followed.
2. 1992: Learning C (on MS-DOS!). ‘nuff said.
3. 1994: Installing Linux, the first Unix-like system I used heavily and my real introduction to free software. At the time I was very keen on FreeBSD (1.1!) but it wouldn’t install into a DOS extended partition and Linux would.
4. 1995/1995: Forcing myself to learn vi (elvis initially and later vim). There was quite a lot of Emacs FUD at the time (It’s so big! It’s so slow! Eight Megs (of RAM) and Constantly Swapping!) that I shied away from it. I regret that a bit today.
5. 1996: Learning Perl, primarily to write CGI scripts. I loved Perl at the time - it was my first exposure to modern “dynamic languages”. I haven’t used it in anger for ~15 years, but it was a huge influence.
6. ~1997: Exposure to version control (RCS and CVS!).
7. 1997: O'Reilly UNIX Power Tools I devoured it and read it from cover to cover several times. I still have the PDF of the 2nd edition (before it went all Linux'ey) on my iPad. The best all-in-one beginner/intermediate Unix book I’ve seen.
8. ~2008+: Exposure to “devops culture and practises” (configuration management, CI/CD, etc). A massive and fairly amorphous area but this led to an interest in all sorts of related topics.
9. ~2008+: Starting to learn about AWS - Amazon just took the whole colocation model (which I was very familiar with) and took it to its logical conclusion.

I’ve done/learnt a lot of other stuff besides the things listed above, but off the top of my head those are the most influential. At least sitting here today writing this!

My career has largely involved around SAP (and it still pays most of my salary today), but in reality it hasn’t really influenced my approach to things. I think of myself as a Unix/open source person in a world of enterprise proprietary software and reconciling the two can be difficult at times.