Skills/Knowledge

In my many free time projects and other activities, I have gained experience in many more areas of software development, than what I saw on the job. The following is a non-comprehensive list of skills, knowledge, or experiences I have gained through free time software development projects and other activities.

  • 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 many (programming) languages in my own projects, but am most familiar with the following:

    • Scheme (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
    • TypeScript
    • SQL
    • Java (whole applications including GUIs, but not recently)

  • 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

      I have only had contact with this, while briefly learning about Prolog and through Minikanren. Fascinating stuff. Haven't build anything with it yet 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.