Pancake Appletree’s site

Hello, world! This is my first blog post.

I recently wrote with a friend of mine about programming languages we like. At some point, I wrote a quite long E-Mail about my experiences with many languages, and my friend told me “why don’t you just publish this to your site?” and I decided to do exactly that. So this blog post will contain what we discussed there.

The only problem was: At that time, my website was already up and running, but I didn’t setup a blogging system yet. Perfect reason to set it up! So now I set it up with my static site engine, Zola, and I might write a blog post about that, too, at some point.

But let’s get back to programming languages.

The programming languages I tend to use are Rust, Python, JavaScript/Typescript, and recently also a bit of Haskell and C.

C

C is everywhere. It’s the language that powers most, if not all computers in the world because it is so widely adopted for systems development. Linux tooling is native for C. All these are reasons to really like C.

I never really liked C. That’s because of various reasons: it’s memory-unsafe, I didn’t like having to define all functions before using them and I read a book which really made me hate the amount of different pointer syntaxes existing (I think it was “C for Dummies” by Dan Gookin in German), although I think in modern C23 there should be a more ergonomic alternative.

But now I got a (fully assembled) Corne Choc Pro keyboard from Keebart, which is a low profile mechanical split keyboard with 42 keys. The cool thing about it is that you can, as with a lot of other custom keyboards, program many features of its open-source firmware QMK such as RGB lighting, layers, mod-tap, leader keys and tap-dance. If none of these terms means something to you, I may make a blog post about it in the future!

And using QMK forced me to use C, which made me look at the language again. Especially the more advanced features such as tap-dance made me see how minimalistic it is and how I actually quite like it’s syntax, because they needed to write functions which a lot of other features didn’t need. What I like about C’s syntax is that when specifying types you prefix them, and there is no keyword for denoting a function, instead you simply prefix the function signature with the return type, as you can see in this example:

#include <stdio.h>

int main() {
  printf("Hello, world!");

  return 0;
}

Haskell

Haskell is only on the list because I experimented with it a bit (I started doing the CIS 194 course, see my progress here) and though I really like (and would like to learn) its principles, I prefer to use Rust because I have the feeling that Rust has a larger ecosystem, being used a lot more often in real projects. Another point is that my library (yes, the real library where you can borrow actual books 📚) has a lot more books on Rust than on Haskell. This makes it harder for me to learn Haskell, as I like learning from books, and it makes me think even more that Rust has the better ecosystem.

A simple hello world program cannot show the capabilities of Haskell (of no language at all actually), but it gives a quick glimpse of how the syntax looks like:

main :: IO ()
main = putStrLn "Hello, World!"

JavaScript (JS)

I try to get a bit more into TypeScript and JavaScript, because it’s literally the native language of the web and I really like the easiness of cross-platform web development, especially in contrast to cross-platform native app development. Yes I know there’s Flutter, but it’s too Google-heavy from my point of view.

Of course, JS is also not that great, it is a very boring language that is actually not that great of a language. But all browsers and thus all halfway modern operating systems can speak it without having to install anything, which makes it an incredibly portable language. But it has many flaws, such as implicit type conversion, which are probably due to JS being oriented at Java, which it also where it has its name and the terrible Date class from.

Yes I know there is WebAssembly, but it cannot call Web APIs directly yet which is a deal breaker for me and makes it a lot less attractive for web dev. However, it looks like eventually it will get the ability to call web APIs natively, because things such as the WebAssembly Component Model already exist, and I think/hope this will evolve into a system enabling that.

On hacks.mozilla.org, there is a good introduction into WebAssembly Interface Types (which makes up a part of the WebAssembly Component Model now). I haven’t read it yet though 😅.

Also, web dev using JS/TS has simply a huge ecosystem opposed to WebAssembly which has none at all.

And now: the obligatory hello world program, showing you all the lovely syntax of JavaScript! (there are no types in here, so this is not really TypeScript)

console.log("Hello, world!");

Python

Python is the language I started with, and I can totally understand why people like it because it just needs a lot less brain capacity to understand Python code opposed to something like Rust. It also currently feels a bit like my “native language” which I can understand without thinking too much. I have learned a lot about Python so I can comfortably write slightly functional code that I like to look at.

Another reason why Python is great: in the last years tooling was improved dramatically. The tools I mean here are ruff, uv and ty. If you don’t know them, ruff is a blazing fast linter and formatter and was the first, uv is a blazing fast package and project manager (“cargo for Python” so to speak) and ty is a blazing fast type checker and language server. All of them are written in Rust and by a company called Astral. This tooling greatly improves my experience using Python because everything is just fast and ergonomic.

But Python is not my favorite language anymore, because I don’t like many of the language concepts itself. For example, exceptions are not great, I prefer my railway-oriented programming and Maybe or Result or Option. I simply want a programming language that enforces more functional-style programming.

In Python, the hello world program is extraordinarily small and simple, which I quite like, but you can also blog it up like that: (the body of the main() function would be enough)

def main():
    print('Hello, world!')

if __name__ == '__main__':
    main()

Rust

And finally Rust is my preferred choice because of many reasons: performance (although it needs more than “just use Rust”), because I simply like kind of every concept of the language (the functional programming stuff like Result, the borrow checker, proc macros, not needing a gc but being memory safe etc) and because the compiler is ultra-helpful. Also, it has a minimal standard library in conrast to the batteries-included approach of Python, which I also quite like. cargo is just a truly awesome tool that uv tries to be for Python, and the awesome Python tooling (ruff, uv, ty) is fully written in Rust and ultra-fast. In fact, most tools I use day-to-day are written in Rust, and that is no coincidence!

When I first read a book from the library (“Programming Rust: Fast, Safe Systems Development” by Jim Blandy and Jason Orendorff) on Rust, it blew my mind. It introduced me to why it is better than C, which was quite funny because I didn’t know C at all at that point. But it made me really love the language and nowadays I can say it’s my favorite language.

The hello world program the tells us nothing about how the language is: (fun fact: you can remove the semicolon in this case)

fn main() {
  println!("Hello, world!");
}

Others

Here I listed other programming languages that I either never used at all and want to check out or that are very specific to one domain I’m interested in.

Recently I’ve been exploring homelabbing using Talos and Kubernetes on a Raspberry Pi 5, which is certainly overkill, but I liked to learn Kubernetes. I noticed many of the tools related to Kubernetes and cloud-native are written in Go, so I’d like to learn Go at some point.

My main text editor I use for coding and anything else related to plain text is Neovim, and it can be configured in Lua what I did of course. The only thing I don’t really like about Neovim is that you need to configure anything, nothing is there out of the box and maintaining a large config with a lot of plugins kind of sucks. Thus in the future I’d like to switch to Helix, which gives you a lot of customizability as well as LSP support and tree-sitter out of the box which is a great experience. The only drawback is that it is a lot less mature than Neovim of course and its’ ecosystem is by no means comparable. It doesn’t even have plugin support yet, although there is a fairly large PR on GitHub implementing this. When the plugin system PR will finally be merged, I will probably write plugins for Helix in Scheme, which is also a great language I read almost the full spec of (I tried to read through and understand the whole 50-page R5RS spec, but I skipped all the boring grammars at the end).

My favorite programming language is obviously Rust, but in secret I have two other programming languages that I quite like on a similar level, but use a lot more frequently: Nushell and Nix.

Nushell is my CLI shell, you could say a bash replacement but it not really is a bash replacement because it is not POSIX-compliant. But instead of handling all data as strings like bash, Nushell’s pipelines can carry structured data such as tables and records which is a lot more mind blowing than it sounds.

Nix is a purely functional (yesss) programming language that is used for configuring my main OS (NixOS) and writing packages for it. I really like it, because it is really made for its domain of package management and system configuration and you feel that when using it. And being so domain-specific also enables it to be purely functional, which is really awesome. Also, although it is very domain-specific, you could write arbitrary programs with it.

Conclusion

That’s my 50 Cents about programming languages. Probably I could tell you more about programming languages, but this blog post is already quite long, so let’s keep it for now.

Happy Coding!