• Development
  • implementing whole new critical services from scratch
  • writing unit and integration tests
  • setting up monitoring solutions
  • setting up CI pipelines
  • developing solutions for automated checking MOOC student solutions of computer programming tasks
  • creating a concurrent backup strategy and implementing a backup system to save the company
  • containerization (docker) of various critical services
  • creating reproducible base images for data scientist stacks
  • developing a service for distribution of educational content
  • frontend development
  • developing an event tracking solution
• Engineering
  • documentation of software, formal and informal diagrams, prose
  • modelling software architecture
  • modelling of databases
• Devops
  • working on server deployment code (infrastructure as code approach) and reproducibility
  • deploying server infrastructure
  • deploying services on infrastructure
  • handling outages
• Other
  • code reviews
  • developing assignments
  • developing online course content
  • reviewing applications
  • reviewing hand-ins of applicants
  • onboarding of new coworkers
  • technical support

This is what happens, when you join a technical startup as 1 of 2 engineers, 1 of the first 10 employees, and need to get cracking at whatever comes your way. When you stick around for a while. When you are a core team member building up the company. For this reason my experience is rather broad, even though this is my first job.

In a way pride myself to be a generalist. However, there is also a specialist side to me. In free time projects I gained a lot of additional experience off the job, that often allows me to make the right decisions at the job.

Over time I have seen many changes in processes at work. I have seen some projects play out over their whole life-cycles. I have seen decisions that later would be regretted and I have seen decisions, that stood the test of time.

• Natural Languages —
  • German (native)
  • English (fluent)
  • Spanish (once fluent, now very rusty, but can quickly get back into it again, since it is an easy to learn language)
  • Chinese/Mandarin (learning, can have fluent conversation with vocabulary approaching HSK3)
• Sport
  • Chess and variants —

    In my youth I played quite a lot of chess and participated in many tournaments. I became quite a good player. My biggest success in terms of region of participating players is probably my first place in the northern German rapid chess championship or the my first place in the Brandenburg regional championship. However, I also got interested in other chess variants, such as the Japanese Shōgi, or Chinese Xiàngqí, and Go. For each of those I have also participated at least in one tournament. I also participated in the World Open Shōgi Championship, when it was in Berlin, and came out as 50th out of 100 players.

    Over time, as my interest in computer programming increased and I got more busy studying at university, I spent less time on chess. Now I am a bit rusty, I guess, but if I were to play frequently again, I think I could rise above my past levels of play.

  • Table tennis —

    I have never actually been in a table tennis club. However, amongst friends I always was a good player and I learned a couple of things from a former coworker, who was in a club. For the amount I played and considering I am not in any table tennis club, I can actually play quite well. Maybe some day I will join a club and become much better.

• (Programming) Languages —

  While I have mostly worked using Python, TypeScript and JavaScript, I have used several many (programming) languages in my own projects, including:

  • GNU Guile
  • Python
  • Racket (used it mostly to work on SICP exercises and create a Markdown blog thingy)
  • Shell scripts (sh, GNU Bash)
  • (GNU) Make
  • HTML
  • CSS
  • JavaScript
  • Elixir (used in Advent of Code 2023)
  • Standard ML (used in Advent of Code, and solved exercises from "Elements of ML Programming")
  • SQL
  • Erlang (dipped my toes in a little, started going through "learn you some Erlang for great good!")
  • GForth (dipped my toes in a little, used in Advent of Code)
  • PHP (way back, in school, making my first websites)
  • Java (a long time ago, whole applications including GUIs)
  • Rust (some time ago, wrote a Markdown blog thingy)
  • Haskell (but I have most forgotten everything about it)
  • Smalltalk (via Pharo, Squeak, but I don't want to claim any proficiency any longer, because I have not used those in a long time)
  • Prolog (very long time ago, only used very briefly)
• Technologies/Frameworks —
  • Django
  • Falcon (Python)
  • Jupyter ecosystem
  • Ansible
  • Machine Learning
  • GNU Guix
• Learning from books —

  Turns out some of them actually are really great learning material, that can make you a better software developer. I read at least partially:

  • Structure and Interpretation of Computer Programs (SICP, by Abelson and Sussman)
  • The Little Schemer (by Friedman and Felleisen, finished)
  • Elements of ML Programming (by Ullman)
  • Software Design for Flexibility (by Sussman and Hanson)
  • The Seasoned Schemer (by Friedman and Felleisen, almost finished)
  • Paradigms of Artificial Intelligence Programming (PAIP, by Norvig)
  • Purely Functional Data Structures (by Okasaki)
• Programming paradigms —

  Most programming languages encourage some paradigm over another, due to how they are designed. I have dealt with the following:

  • Functional programming (FP) —

    Scheme, Elixir, Erlang, Standard ML, Haskell, they all encourage FP or similar style. Since GNU Guile is my favorite language, I try to find ways to solve problems using the functional programming approach and often succeed. One of the biggest challenges are situations, in which one does not have the persistent data structure one needs and then needs to look up how to write one. I think having purely functional data structures available is one of the cornerstones of being able to write code the FP way.

  • Object oriented programming (OOP) —

    Of course I have dealt with OOP a lot as well. Mostly on the job, but also in the past in my free time projects. It has its uses, although I mostly try to avoid it, when it is not strictly the better option.

  • Relational programming —

    This I have only had contact with briefly through Prolog and through Minikanren. Fascinating stuff. Haven't build anything with it though.

• Metaprogramming —

  A little bit obscure, but quite important for understanding programming languages.

  • Function contracts —

    Schemes tend to have very powerful macro systems. GNU Guile is no exception. The most complex thing I have build using macros are new define forms, that allow the programmer to specify function contracts (see Projects).

  • Docker library —

    Another thing I built using macros is a tiny library, that defines procedures for interacting with docker via the docker socket REST API, based on the names of the endpoints.

  • Threading/Pipelines —

    In computer programming it happens all the time, that one has to use the result of one function as input to another function, and then the result of that other function as input of yet another function, and so on and on. One way to write code in a more readable way is to use threading (not to be mixed up with multithreading, multiple processes, concurrency or parallelism!) or pipelines. I use a rather simple macro im my Guile code, that facilitates this. It serves as an example for good usage of macros, that helps to improve readability, rather than making the code more difficult to read.

• Containerization —

  For reasons like isolation, heterogeneity of services, ease of deployment, and scaling, it has become common to containerize services. I have done this on the job as well as in my own free time projects using docker.

• Server management —

  I gained experience in setting up and managing bare metal servers and virtual servers (Hetzner and Ionos) on the job and in free time projects, hosting and orchestrating webservices and websites, setting up backups, and running deployments. I have used Ansible and literate devops tooling (Emacs org-mode) for managing such servers.

• Parsing —

  Over time I have implemented quite a few parsers, mostly using PEG parsing. For example for puzzle input of Advent of Code puzzles, or for file format of an old game. I also have another project writing a parser for Emacs' org-mode file format. I claim that through these experiences I have become somewhat proficient in writing parsers.

While computer programming is totally my thing, on the job, as well as off the job, I also have other interests.

I like to play chess and chess variants like Japanese chess (Shōgi) or Chinese chess (Xiàngqí). I used to be a club chess player in my childhood and achieved quite good results. These days I only play online sometimes, or perhaps with friends over the board, or perhaps with strangers, if there is some kind of event. But I did not participate in a proper tournament for years, due to the time commitment needed.

Considering, that I have never been in a table tennis club, I play quite well. Learned a couple of tricks from a club player at some point though.

In my free time I also learn Mandarin. I take regular online lessons and can survive on my own in China. Simple conversation is not a problem, but I still have lots to learn. Especially vocabulary.

I enjoy reading novels. Usually fantasy or science-fiction novels. I read all of the original Dune novels and then some. Or the Barrayar series novels. I think in total I probably read more sci-fi than other genres. Grand ideas about the future and philosophical questions fascinate me.

Sometimes I also do some story writing, with long creativity breaks in between.