Goodbye 2019, Hello 2020

Wrap-up and new goals
The text "wrap-up 2019, new goals 2020" across a graphic that mixes a variety of logos: this blog, Kubernetes, OpenShift, Haskell, Emacs, and Nix

One year gone, another one about to begin. Bring it on.

It's the end of the year and there's round-ups and predictions everywhere, so I think it's an appropriate time to take a step back and look at what I've achieved this year and what I have in mind for next year.


Let's move in a chronological fashion. In 2019, my list of goals was just a slightly-longer-than-usual Slack message to my friends. They were pretty vague, but still hold some value as a set of overarching goals.


  • Containers ::

Before 2019, I'd hardly ever touched a container. I'd heard lots about them on various podcasts and was really intrigued. I wanted to 'really familiarize myself with the whole thing' (how's that for a vague goal?).

A year later, do I think I've succeeded? Yes. It's stated in a very unclear fashion and can be taken to mean a lot of things, but since then, I've been working pretty closely with containers and Kubernetes pretty much the entire time. Yes, there's still some things that are unclear to me, but overall, I think I understand containers well enough to have cleared that goal.

  • NixOS ::

I installed NixOS on my personal computer pretty much exactly a year ago. It was (and still is) my first real foray into the Linux world. I'd used Ubuntu for some university assignments previously, but that's it. It took me a good few weeks to get my external monitors up and working, but these days, most everything is running pretty smoothly (except for that NVidia GPU I've got ...).

I said that I'd 'just got it set up over Christmas, but there is still a lot left to be done and a lot of things to discover.' A year later, I'm fairly comfortable in NixOS, I use Nix for a lot of work related stuff, and I love it. I'd say I've finished the NixOS setup and discovered much, though there is still a lot left to be done. What I have achieved is: I have a stable operating system that works as I expect and with a window manager / desktop environment that I enjoy. I'm happy with the OS state of things for now. Achieved.

  • Give a talk ::

Said at the time: 'This is something I've been wanting to do for a while, and I think this year is the right time, once I'm out of uni and have a bit more time (and experience) on my hands.'

This is probably the one goal I set for myself that is the easiest to measure. I spoke internally at my company about Algebraic Data Types, I held a workshop (still counts) on re-implementing some basic data types and creating opaque types at Oslo Elm Meetup, and I held a talk about the new async/.await features in Rust at Rust Oslo. Done.


In addition to the above goals, I also achieved a few other things that I'd like to highlight in this post. These are items that I didn't put on my to-do list, but that I consider significant enough to mention.

  • Kubernetes/OpenShift ::

I started working in a team where OpenShift is an important part of the workflow, and interacting with it became a natural part of my day-to-day work.

Took me a while, but I finally got going. It's been a lot of work, but very rewarding.

I'm excited to see what we can do to further engage the Rust community in the vicinity and what we'll be doing in the coming year.


Looking forward to 2020, what do I want to achieve? What skills do I want to develop? After some thought, I've come to the conclusion that my 'theme' for 2020's goals is mastery. I've found tools that I really like and that align with my way of thinking. However, I don't feel like I've fully mastered any of them just yet. Most of my goals will revolve around improving my skill with tools that I already know and love.


Here's a loose definition of my goals for the coming year.

General goals

These are the general goals that I'm setting for myself. These are the ones I will actively be pursuing and working towards.

  • More infrastructure work ::

Building on the 'containers' goal of this past year, I want to keep working on infrastructure: Kubernetes, CI/CD pipelines, containers, the whole deal. I went through a Red Hat training course this year, working towards a certification as a 'Specialist in OpenShift Application Development'. I failed the exam, but learned a lot in the process. Let's see if I can use that to pass! Apart from that one specific goal, this post is more about making myself familiar with the tools and getting really comfortable with them. You know, mastering them.

More Nix
It's been a year of NixOS, and it's been great. Now I want to get really comfortable with the difference between build.nix, default.nix, shell.nix, how nix-build works, etc. Specifically, I'd like to be comfortable with setting up a Haskell dev env with Nix and Cabal.
More Emacs
Emacs has been my go-to editor for a year and a half now, and I still get stuck in weird states sometimes. This coming year, I want to get more comfortable with it on a deeper level. Step one: Read the built-in Emacs manual.
More community engagement
I gave some talks and workshops, both internally and at local meetups this past year. I want to do more of that in 2020. Also: apply for more conference talks. I applied to a few this past year, but didn't get any of them.
Programming Language Theory / Compilers
I've had an interest in type systems and PLT for a while. While writing this post, I realized I should do something about it and ordered Types and Programming Languages by Benjamin C. Pierce. I don't know enough about it to set any clear goals just yet, however.


While I'm not going into this coming year with any clear language goals in mind, I'd like this to serve as a recording of what languages have me the most curious at the moment. I'm not making any clear commitments to learning any of these, but I think it's important to keep an open mind and keep exploring new languages and new concepts. As Scott Wlaschin talks about in his talk Four Languages from Forty Years Ago, you should look for languages that expand your mind and help you think about problems in a new way. He awards languages that achieve this a 'Galaxy Brain Seal of Approval'. There is an Alan Perlis quote in the slides saying that 'A language that doesn't affect the way you think about programming, is not worth knowing'.

Yeah, I've been doing a bit of this, but not enough. I've got the basics down, but I need to put it into practice. I want to build something; a simple Web API or command line interface should be enough.
Doesn't matter whether it's common lisp, scheme, (typed) racket, or clojure: I want to get comfortable with lisp. If nothing else, at least it'll help me configure Emacs.
This is the wildcard on the list. I have not really looked much at it at all, but I hear great things. Should offer some nice Galaxy Brain moments.

SMART goals

The goals listed above are generally quite vague, and it'd be hard to say for sure whether I've achieved them or not. To make them more actionable, let's create a set of SMART goals that I can tick. What are SMART goals? Of course, Wikipedia has an article on it, but the short version is that SMART is an acronym that stands for 'Specific, Measurable, Achievable, Relevant, Time-bound'. Organized by topic, this is my list:

  • Programming Language Theory ::

I don't have enough insight into this to make any clear goals for it, but I've had a brief look at the Types and Programming Languages book. It's about 650 pages long. I'd say I should get through it by July at latest. In short: Read Types and Programming Languages by July.

  • Community engagement ::
    • Give at least three talks/workshops at community events.
    • Apply as a speaker to at least three conferences.
  • Emacs ::

By February 1^st, I want to have gotten through the Emacs manual. At this point, I may decide to try and (at least start to) configure Emacs from the ground up (rather than relying on Spacemacs), but that is not a requirement.

  • Nix ::

Write about what the various .nix files are and what their intended use is. Should discuss at least build.nix, default.nix, and shell.nix.

  • OpenShift ::

Pass the Red Hat Certified Specialist in OpenShift Application Development exam.

  • Containers / Infrastructure / Haskell / Nix ::

This is a set of goals that apply to broad range of topics. I want to manage a Kubernetes cluster somewhere and create a Haskell API that serves requests. The Haskell project should use Nix for as much as practically possible. What sort of data the API serves doesn't matter.


April 1^st
Have Kubernetes cluster up and running.
June 1^st
Have the Haskell API up and running.

And that's what I'm planning to look into in the coming year. As always: plans change, life happens, and things inevitably don't go as expected, but it's nice to have a little something to look back on, at least. What do you think? Do you have any clear goals?

Thomas Heartman is a developer, writer, speaker, and one of those odd people who enjoy lifting heavy things and putting them back down again. Preferably with others. Doing his best to gain and share as much knowledge as possible.