1. 15

This question was recently asked on HN and it generated some really great discussions, so I thought it would be interesting to pose the same question here. Here’s my list:

~20 years ago: Vim

Seven years ago: Haskell

A year and a half ago: Reflex FRP with GHCJS

These three events dwarf everything else in my experience.


  2. 12
    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.
    1. 1

      If you don’t mind, care to expand a little bit on how they changed your carrier?

      1. 10
        1. Relational DB - I’d not even heard of relational DBs. This is pre-ORM, pre-Database Administrators. My role was to evaluate how we might use relational databases for electronics design and simulation tools. Among other things this shaped the way I evaluate software - as a tool for a purpose with strengths and weaknesses. And I’ve also developed a useful perspective on relational databases vs. other data models, query languages, etc. I’m often surprised at the perspectives and “baggage” other programmers bring to the topic based, from what I’ve seen, on the “culture” that developed around relational databases as well as the intent to use it for what does not provide: a complex object-oriented data model, for one example.

          Common Lisp - I’d already used several Lisps, mostly MacLisp on a PDP-10 / TOPS-20. Again my role was evaluating how we might use CL for developing ECAD tools and I learned valuable lessons in making objective technical assessments. Moreover CL caught the attention of several co-workers, some with Lisp experience, some not. This led me to see Lisp as a language for developing real software for production. My previous experience was in school, where I had a fair bit of paid programming experience, but did not have nearly the perspective on these kinds of evaluations and decisions.

        2. My experience with CL reignited my appreciation of Lisp and led directly to joining Boeing to work on electronics manufacturing planning with Lisp Machines. Lisp Machines taught me that $100,000+ per developer for H/W and S/W can pay off big dividends. A good bit of that experience is available today via open source. But that remaining 20-30% or so sure is valuable and missing today. One way that may have affected me is that I’ve had no problem spending many thousands of dollars for development tools over the decades.

          Smalltalk and the Tek 4400 taught me Smalltalk and Lisp are two sides of the same coin, and I prefer using either of them to any other… coin? Simple, expressive languages with really good runtime tools continue to be my preferred method of development. I was also part of the team making the decision to use Smalltalk on $20k machines vs. Lisp Machines at 5x the cost for end-user applications. So further experience at technical evaluations and also my first experience with some aspects of budgeting.

        3. KnowledgeCraft solidified my foundation in logic, rules, and semantic networks. This has shaped the core of what I’ve brought to nearly every software system I’ve worked on since. A small but growing segment of the software industry is beginning barely to scratch the surface of this with things like GraphQL. The Semantic Web folks are squarely there for information analysis systems, less but increasingly so for operational systems.

        4. I ended up using GemStone several times over the years and worked there for 5 years in the late 1990s. This shaped my understanding of relational databases and the misnamed “NoSQL” which is really a wide spectrum of capabilities other than RDBMS / SQL. I also learned a lot about what came to be known as “software transactional memory” – both good and bad. Among many other things.

        5. Jini and JavaSpaces are just the best thing about the Java landscape, and one of the best things in the distributed systems world, period. However virtually unknown and drastically under appreciated. However it continues to be at the core of how I think about distributed systems generally. Even the good software I’ve used since pales in comparison.

        Hope this helps.

        1. 1

          Thanks! Much appreciated

    2. 7


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


      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.


      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.

      1. 7

        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.

        1. 4
          • ~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.
          1. 2

            What is OTP and why is it, and Elixir, great? I see lots of posts on here tagged for Elixir and it makes me think I should look into it.

            1. 3

              OTP is a bunch of middleware that drives erlang/elixir/lfe/BEAM-langs'. Bundles of libraries for common tasks that are considered integral to [erlang|elixir|et al]. Elixir is a fancy new language built atop the BEAM vm (like erlang) with erlang interop, macros, and other neat things. If Lisp Flavored Erlang didn’t exist, I’d say Elixir is to Erlang what Clojure is to Java. (Not that I have any real experience wth these things. Someone wwho actually makes use of elixir and/or OTP care to correct/clarify/elaborate?)

              1. https://en.m.wikipedia.org/wiki/Open_Telecom_Platform
              2. https://en.m.wikipedia.org/wiki/Elixir_(programming_language)
          2. 3

            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.

            1. 1

              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.

              1. 3

                Yeah, I can definitely agree with your choice of Emacs. I recently switched from Vim to Spacemacs and it was a significant jump in my productivity. I almost put it in my above list, but decided not to because although it was a big improvement, it wasn’t quite as paradigm-shattering and career-changing as the other three.

              2. 1

                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.

                1. 1
                  • 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.

                  1. 1

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

                    1. 2

                      Before Haskell I wasn’t really interested in web development at all. Haskell single-handedly made web development interesting (and a lot of other things more fun too) because it provided a learning challenge and abstractions that were up to the task.

                      Before Reflex and GHCJS I wasn’t really interested in front-end development at all. Reflex single-handedly made front-end development interesting because it provided a learning challenge and makes complex interactive and composable GUIs enjoyable to write.

                    2. 1
                      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. 1

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


                        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).

                        1. 1

                          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!)

                          1. 1


                            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!


                            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!


                            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.

                            1. 1
                              • 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.
                              1. 1

                                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.

                                1. 1

                                  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.