Hi, I’m Valentin! on vknabel

Prima Facie

Sat, 27 Jun 2026 16:21:06 +0200

I devoured this book. Told from the perspective of a defense attorney, it explores sexual offenses, critiques the legal system, and exposes the immense obstacles victims face in seeking justice, as well as the alarmingly high number of unreported cases.

The story is compelling and beautifully written—you feel and live every moment alongside the protagonist. The pacing is expertly controlled, with intense passages balanced by quieter, reflective ones. If you’re looking for an emotional, well-crafted book that reads effortlessly, you’ll find it here—and be delighted.

James

Mon, 15 Jun 2026 21:31:58 +0200

The book follows a slave in the southern USA during his escape journey. Based on Huckleberry Finn: a book I’ve never read. Hence I read it with relatively few preconceptions. Topic-wise James tackles a dark chapter of humanity, particularly of the USA, but only touches lightly on the harsh sufferings.

The ending feels a bit rushed and has a somewhat forced happy ending. It’s enjoyable to read, yet I felt the author unnecessarily held back on his criticism.

Nationales Sicherheits-Amt

Mon, 25 May 2026 00:00:00 +0000

What if electric computers and the internet existed before the nazi regime and the second world war? This book begins with a glimpse what surveillance and exessive data collection can be used for in a totalitarian regime, effectively even worsening the holocaust.

The story is written around two characters, their role in the hypothetical “Nationales Sicherheits-Amt” (National Security Agency) and ultimately their personal fate. The story is gripping, but in my opinion the story is a bit too much focues on the characters and a more broad view is missing. While at the first half of the book you can closely follow the development of a dystopian system, the story disconnects and solely focuses on the characters. Only at the very end, when there isn’t anything to tell anymore, the consequences to the system and the people within are show. I wish there would have been more details here. The end felt a little bit too abrupt for me.

Nevertheless I still enjoyed the read and recommend this book.

Bikepacking: Descent to Italy

Fri, 10 Apr 2026 21:30:00 +0200

Today, I would like to invite you to join me on a calming adventure through winding streets, quiet little towns and magical forests. Make yourself a drink, get comfortable and relax. Take a sip. Take your time. I’d like to take you to a place at the back of my mind.

This blog post has been written for the IndieWeb Carnival topic Adventure hosted by Pablo.

Once you wake up, it’s still early in the morning. You get out of your tent. The sun slowly climbs up the mountains and shines down on the valley below. You grab a snack, pack up your tent, and load everything onto your bicycle. Let’s hop on and start our day!

Your path follows a nearby river through a ravine. You can hear the water rushing and the leaves rustling. On the opposite bank, near the cliff, you can see a medieval outpost. Birds fly around, visible through the trees. Follow the path alongside the river. After crossing the river on a small bridge, you find yourself at a mountain pass.

This is the final challenge you must overcome before reaching Italy. Slow and steady. The path ahead is smooth. You know the drill. Slow and steady. You start climbing.

After a few switchbacks, you suddenly notice the breathtaking view. You look down into the valley, which is waking up in patches of sunlight. Forests cover the mountainsides, basking in the spotlight. The light warms your skin, giving you a boost of energy.

You continue climbing. A drop of sweat runs down your forehead. You are getting close to the top. It’s still early morning and it’s still cool. You greet some forest workers along the way and take the final winding path. You are almost there. Suddenly, a new view opens up on the other side of the mountain.

This side is shrouded in mist and clouds. Below, you can see a small, picturesque Austrian mountain village. Groups of trees break through the mist.

It’s time for a break. You sit down on a bench, grab a snack and take a sip, enjoying the view for a few minutes. This side is less misty, but cloudier. You put on your wind jacket and begin your descent. The road is wide and fairly straight. The village gets closer and closer. The wind hits your face and lifts the corners of your mouth.

You brake to slow down and drive through the alpine village, with its wooden houses adorned with flowers on the balconies. You follow the roads that lead you out of the village and into the green, grassy valley beyond. It starts to rain lightly.

In front of you is the last hill. It’s small and flat, but it obscures your view of what lies beyond. You still have lots of energy left, and you know there’s a reward waiting for you at the top. You stand up on your bike and start pedalling hard. In about half a minute, you reach the top.

The view opens up to reveal a blue lake surrounded by mountains. In the middle of the lake, a lonely church tower rises from the depths of the water.

Continue along the pavement on the left side of the lake. Follow it along the riverside, cross the river and find yourself on the opposite bank in a forest. The narrow road is surrounded by a beautiful green, mossy atmosphere. Birds sing around you and sunbeams filter through the canopy of trees.

Focus on the moment. The winding road leads you downhill. You accelerate. Press the right pedal, lean to the left, and take the curve. Your eyes are fixed on the next bend. Right. You flow through the curves. You lean down and let the bike do the work. Left. It’s just you and your bike. Right. The rain stopped long ago. Left.

Suddenly, the canopy of trees opens up to reveal the blue sky behind. You sit up straight and slow down.

A town with a mix of alpine and Italian buildings appears in front of you. You drive down the cobbled streets and find a place to get some pizza and a cup of coffee. You enjoy your break, reflecting on what you’ve seen and experienced today.

After some time, you continue your descent and leave the hilly village behind. The landscape changes. Now, you drive through apple orchards and vineyards. The mountains surrounding the valley become smaller and feature ancient ruins and castles on their slopes. It slowly gets warmer and warmer. Occasionally, you are cooled down by a few droplets of water from sprinklers.

You arrive in a tiny town with a small church near the town square. The buildings are made of sandstone and the streets are narrow and cobblestone. People are chatting in the town square. The sun brightens up the scenery. You leave the painting untouched and continue your journey alongside a new river. The water is greyish-blue and fast-flowing.

It is still flowing downwards, so you don’t have to pedal much. As you go along, you see more and more people around you. Some are walking and some are cycling. Compact tractors transport stacks of apple crates several metres high.

Near the riverbank, you spot a small stall selling sweet apple juice. You stop to refill your bottle. You take a refreshing sip. After all that work, the sweet, sugary juice tickles your brain and a spark of joy hits your throat.

You come to a small avenue lined with trees. At the end of it, huge chairs are perched on the edge of another valley. Dozens of metres above the ground, you can see the city. Your goal. Tiny cars and people move slowly around like toys.

You take the route down, with bushes, trees and flowers on either side. You take each turn. A couple of minutes later, you arrive at the horizon that was just in front of you a few moments ago. The city. Cypress and palm trees line the roads. The quiet, peaceful atmosphere vanishes, replaced by a colourful medley of people, dogs, bicycles, delicious smells of food, and music.

You spot a lovely café near the river. You sit back and watch the world go by, calming down as you do so. As you drink your espresso and eat your cake, you reflect on your day. How far you’ve come! What you’ve seen. The things you’ve felt along the way.

I hope you enjoyed this little trip through my memory. Adventures like this can’t be made online or at home. Whatever motivates you, let it lead you wherever you want, whenever you want. Load up your bicycle or backpack with everything you need and go out and explore the world.

This was day three of my adventure from southern Germany to northern Italy from 2025. The route described starts in Austria just before the Reschen Pass (Passo di Resia) and ends in Merano. It follows the Via Claudia Augusta route.

Switching From Let's Encrypt to Actalis

Mon, 02 Mar 2026 16:41:56 +0100

In my ongoing efforts to reduce the reliance on US companies and services, I decided from Let’s Encrypt to the Italian Actalis. Sure, Let’s Encrypt works fine, is non-profit and had a huge impact on today’s internet security, but nonetheless it is still US based and required to comply with US law and government requests. This could also include breaking the chain of trust for certificates while prohibiting to share this information with the public.

Actalis, on the other hand, complies to European laws, regulations and standards.

I operate a Kubernetes cluster with cert-manager and DNS01 challenges. Actalis provides these too, making the switch fairly easy.

Create an Actalis account.
Copy your ACME Key ID and the HMAC.
Create a new secret in Kubernetes with these values.
Create a new Issuer or ClusterIssuer in Kubernetes, referencing the secret created in step 3.
Reference the new issuer in your Certificate resources.

---
apiVersion: v1
kind: Secret
metadata:
 name: actalis-eab
 namespace: cert-manager
stringData:
 # no trailing `=` in the HMAC
 hmac: "$YOUR_HMAC"

---
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
 name: actalis-prod
spec:
 acme:
 email: "$YOUR_EMAIL"
 server: https://acme-api.actalis.com/acme/directory
 privateKeySecretRef:
 name: actalis-dns01-account-key
 externalAccountBinding:
 keyID: "$YOUR_KEY_ID"
 keySecretRef:
 name: actalis-eab
 key: hmac
 solvers: # if you are switching, just keep it as is
 - dns01: # due to my setup only DNS01 challenges make sense
 cloudflare:
 apiTokenSecretRef:
 name: cloudflare-credentials
 key: api-token

Perfect, now we’ve got Actalis set up and we can start issuing certificates.

But there is one downside: Actalis does not support multiple domains per certificate in the free plan. Splitting these into multiple certs and secrets does solve this fairly easily though.

I understand if this is a deal breaker for some, but in the end, these are just a few lines that are simple and easy to maintain.

---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
 name: first-domain
spec:
 secretName: first-domain-tls
 issuerRef:
 name: actalis-prod
 kind: ClusterIssuer
 dnsNames:
 - first.domain # only one dns name supported
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
 name: second-domain
spec:
 secretName: second-domain-tls
 issuerRef:
 name: actalis-prod
 kind: ClusterIssuer
 dnsNames:
 - second.domain # and here is the second one
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
 name: both-domains
spec:
 # here we need to supply both certs
 tls:
 - secretName: first-domain-tls
 hosts:
 - first.domain
 - secretName: second-domain-tls
 hosts:
 - second.domain
 # the rules stay untouched
 rules:
 - host: first.domain
 http:
 paths:
 - path: /
 pathType: Prefix
 backend:
 service:
 name: service-http
 port:
 name: http
 - host: second.domain
 http:
 paths:
 - path: /
 pathType: Prefix
 backend:
 service:
 name: service-http
 port:
 name: http

And that’s it! For more services and ideas you could get rid of big tech and the US, check out Sovereignty.

The Grand Redesign

Thu, 26 Feb 2026 22:13:55 +0100

Nine years ago I launched this blog to share some thoughts about software development. Most of the time I have been very strict about content that I posted. If it wasn’t tech, I didn’t post it.

Over the years my priorities shifted. I even started a new blog to open up a new niche. But in the end I decided to not restrict myself in terms of topics. Let’s see where this leads me to.

How it started

Back in February 2017, that’s nine freaking years ago, I launched this blog. I just picked some template and some static site generator to get started. The blog was built using Gatsby with some simple theme.

The problem with Gatsby

With the years I was increasingly frustrated with Gatsby. I wanted a simple blog, nothing too crazy client side stuff. But essentially that was the focus of Gatsby: web workers and lots of JavaScript.

When I left day to day web development, I also switched to Hugo. After all the hassle this was a breeze! I picked a new theme that was simple, but less basic and had a touch of color.

Essentially I was pretty happy with my site. But as teased above not with the topics I was writing about. I started a new website Aroid Garden about houseplants, but also lost focus there due to personal reasons. Eventually I sunsetted it.

Why the redesign?

Now I decided to transform my former tech blog to a personal one. If I want to write something down, I don’t want to think about wether the topic fits or not. Writing is a habit that must be built and maintained, but I regularly focus on other stuff than tech.

Though the markdown-style design just doesn’t fit the new content I want to share. That’s why I decided to go with the redesign. As it’s been a great choice I sticked to Hugo, but couldn’t find a theme that fit my needs, so I rolled my own. For technical details about this site see Colophon, which will be updated in the future.

I know there are still some rough edges around the design, but better ship, than procrastinate.

What about the content?

When mixing many topics, it makes sense to provide ways to navigate and filter it more easily.

refactored the tags that grew over the years (I had go and golang)
separate RSS feeds for the blog, library and one for all content

I also provide additional content like:

a book library to share book recommendatations
a now page to share what I’m currently doing
the colophon to share technical details about the site
my list of projects
and sovereignity to share my efforts to regain control over my data and online presence

Also some updated content:

the about page was just outdated
I imported the Aroid Garden posts to the plants tag, though the layout isn’t optimized for it

In the end, when you have a look at Home, you cannot come around to see that my content has changed. And that this is just the beginning.

Now

Thu, 26 Feb 2026 00:00:00 +0000

From time to time, I like to share what I am up to and how I prefer to spend my time. Currently I mostly do some Homelab stuff, riding my bicyle and enjoying my life in general.

My latest blog posts are Hack the Garden No. 8 🔨 on metal-stack.io and Infrastructure as Code erklärt: Mehr Kontrolle, weniger manuelle Fehler on x-cellent.com (German).
The last book I finished is Prima Facie by Suzie Miller after aborting Text by Dmitry Glukhovsky.
I currently read Das Wesen des Lebens by Iida Turpeinen.
By day I work as a Kubernetes and Go Engineer at x-cellent. You might even spot me on their website, too.
By night I mostly tinker with my Homelab.
~~If the weather is great there is a high chance I am riding my bicycle right now.~~ Yikes, I crashed in May.
During rain or on the train, books are great!
Trying to break 5.5k by bicycle. I am a few hundred kilometers behind my schedule.

At the moment I mostly focus on my homelab and digital sovereignty. Other than that, most side projects are currently on hold.

Stuff outside of the digital world is just too joyful right now.

In case you understand German, you can check out a quick and fun interview on LinkedIn of me made by x-cellent. Nothing too serious and not that long, but it gives you a little insight into how I am.

Sovereignty

Wed, 25 Feb 2026 19:53:11 +0100

The development of global and especially US politics in the last decade made it clear that Europe must become more sovereign and independent from the US. And the same applies to everybody in the world regarding big tech.

This here should be some kind of dashboard to reflect my current efforts and challenges. Maybe this inspires you to replace some technology with a better one. I can recommend European Alternatives to start with your research regarding alternatives.

But beware: this conflict is not a personal one. Politics need to act and implement ntives to drive change. That beign said, take all this with a grain of salt, but maybe this might help you, too.

Apple

I still own an iPhone and Mac. I will continue using these as long they still fit my use cases.

AppleTV: still streaming.
iCloud: canceled subscription. Self-hosted NextCloud for files and Immich for photos.
Apple Music: canceled subscription. Moved to Spotify long ago.
macOS: proud Linux user at work. arch btw
Mail/Calendar: switched to Proton. There are other great alternatives.

Cloudflare

This is a tough one for sure. Due to the architecture of my homelab and the fact that I do not get a public IPv4 address, I use Cloudflare Tunnel to expose my services to the internet. That paired with DDoS protection and great firewall capabilities (looking at you Facebook) switching away from it will be pretty tough for me. Nonetheless I stop using more services.

S3: self-hosted Garage.

GitHub

Let’s be honest GitHub under Microsoft kind of sucks with all their bugs and AI stuff. Sadly there is no realistic way to get rid of it entirely. I depend on it at work and privately.

Here is what I’ve done so far:

Self-host Forgejo at code.knabel.dev.
I moved nearly all my repositories there. Including private and public ones. Only a few that cannot be moved remain.
I have a local CI/CD runner that is GitHub Action compatible.
GitHub Pages: still using. Going to move to self-host using Garage as well.

Google

Search: I switched to Ecosia long ago. Seems less of a harm for the environment, is German and does not track me. Win-win.
Drive: Self-hosted NextCloud.
Photos: Self-hosted Immich.
Mail/Calendar: switched to Proton. There are other great alternatives.
Youtube: account deleted. Still watching there, but more and more videos are available on Spotify.
Account: deleted.

Netlify

Currently I still host zirric.knabel.dev there, but I am going to move it to self-hosting with Garage as well.

Microsoft

Besides GitHub, I still own an Xbox.

Xbox: buy Games second hand or hard copies.
Mail/Calendar: switched to Proton. There are other great alternatives.
VSCode: switched to Helix.
VSCode Marketplace: can’t delete account yet to keep extensions up.

Depending on the person, this might be easy or straigt up impossible.

WhatsApp: hard to get around this in Germany. I switched for most chats to Signal. A few group chats sadly cannot be moved.
Twitter / X: account deleted. Move to Mastodon.
Instagram: account deleted.
Reddit: account deleted.
Youtube: account deleted. Still watching there, but more and more videos are available on Spotify.

1Password / Password Manager

After long years of using it, I just wasn’t happy or comfortable anymore. Switched to self-hosting Vaultwarden.

More Services

Let’s Encrypt: switched to Actalis for TLS certificates on their free plan. See my blog post for details.

Projects

Wed, 25 Feb 2026 18:34:13 +0100

In my life I worked on many projects, both private and at work. Here I highlighted the most important and interesting ones. If there is no link, they won’t be listed here.

Private Projects

This very website. See Colophon for more details about the tech stack.
My Homelab built on Kubernetes and Talos.
Zirric is a small programming language that favors declarations, readable data modeling, and annotations that describe capabilities without interfaces. The successor of Lithia. Go, Docker, GitHub CI, Tree-Sitter, Language Server and more.
Zirric docs is the documentation site for Zirric. docmd.

At Work

In general I essentially work on the open source bare metal Kubernetes provisioning platform metal-stack and our reference metalstack.cloud that provides Kubernetes as a Service.

Here are some open source highlights:

cluster-api-provider-metal-stack Cluster API provider for metal-stack. Not just Gardener.
terraform-provider-metal-stack to provision metalstack.cloud clusters with ~~Terraform~~ OpenTofu.

Discontinued Projects

Lithia is my experimental, functional programming language. Go, Docker, GitHub CI, Tree-Sitter, Language Server, Typescript, VS Code extension and more.
Maintained Swift Development Environment (SDE) provides Swift autocompletion to VS Code on macOS and Linux. Swift, Typescript, Docker, Language Server, VS Code extension and more.
Puffery is a SwiftUI iOS App and Vapor Server to send push notifications fueled by Siri Shortcuts. Swift, Vapor, Docker, GitHub CI, Bitrise, Xcode Cloud, PostgreSQL, Redis.
go puffery. The TUI for Puffery. Go, Bubble Tea, GoReleaser.
SwiftLint for VS Code: a plugin for SwiftLint. Typescript, VS Code extension.
apple/swift-format for VS Code: a plugin for apple/swift-format. Typescript, VS Code extension.
SwiftFormat for VS Code: a plugin for SwiftFormat on macOS. Typescript, VS Code extension.
Archery allows you to declare all your project’s metadata and what you can do with it in one single place. Swift, Docker, GitHub CI.
All my VS Code extensions are discontinued.

Visit my GitHub profile or code.knabel.dev for all open source contributions.

Colophon

Wed, 25 Feb 2026 00:00:00 +0000

This website is built using Hugo and hosted on GitHub Pages. The whole source code and configuration can be found in the GitHub repository.

The theme is hand-written and also available in the same repository. If you wonder what the previous template was: Archie.

The fonts I use are:

Lora by Cyreal. It’s mostly used for headings and the logo.
Inria Serif by Black Foundry. Used for body text.
Monaspace Argon by GitHub. Used for code snippets.

The color scheme loosely oriented around these colors from the Fiery Passion Blend, then piped through a Tailwind CSS color palette generator and now has different hexes.

Trophy

Mon, 23 Feb 2026 14:53:25 +0100

This book captivates from the very first minute. At its core are the moral beliefs of a hunter and where they can lead. There is no judgment—just the story told from his perspective.

At times, his thought processes are almost unbearable to read when they fundamentally clash with your own beliefs. Roughly halfway through, the story provides an outlet for the internal conflict you feel.

The book takes a clear stance without preaching, without condemning, without jumping to conclusions. The story stands on its own and resolves the contradiction through its plot.

I can wholeheartedly recommend it.

Kein Guter Mann

Fri, 06 Feb 2026 14:53:31 +0100

It is slowly told and a bit sluggish in the middle. There are occasionally uncomfortable passages to read because they aren’t properly reflected upon at the time.

The ending is beautiful and emotional. But, as you read, you often wonder why. Yet people like that existed and were considered normal for the time.

Discontinuing of Projects

Fri, 02 Jan 2026 00:00:00 +0000

Starting with this year, I have decided to discontinue all of my open source projects.

Most notably this affects my VS Code extensions for Swift. I archieved the repositories and requested to deprecate the extensions in the Visual Studio Marketplace.

Also I decided to stop my work on my toy programming language.

Reasoning

Since a few years I shifted my focus from Swift development to Go and Kubernetes and switched my main editor from VS Code to Helix.

And I found joy in so many different things that can be done without computers. Doing some side projects just isn’t worth the hassle for me anymore.

Occasionally I will still write some blog posts and update my non-archived repositories.

Zirric: Going Virtual

Sun, 28 Sep 2025 00:00:00 +0000

A few years ago while I started working on Lithia, I decided to use whatever takes me to my goal. Getting finished was the primary focus. And I did.

With Zirric I want to take less compromise and build a better language. Performance and portability aren’t completely irrelevant anymore.

This blog post is part of a Journey about creating a new programming language.

The Tree Walker

For Lithia I chose to implement a tree walker interpreter. It is simple to implement and easy to understand. The downside is that it’s slow.

Here the interpreter walks the abstract syntax tree (AST) and executes the program directly. This means that every time a function is called, the AST nodes for that function have to be traversed again.

In this approach every node in the AST has an evaluate method that takes the current context as a parameter. The context holds variable bindings and other state information.

Variables and constants were stored in a map. During every variable access, a lookup with the string name of the variable had to be performed. In case of a miss, a parent context had to be checked as well until the variable was found or the global context was reached.

let a = "global"

func do { =>
 let b = "local"

 print a // lookup "a" in current context -> miss -> lookup "a" in parent context -> hit
 print b // lookup "b" in current context -> hit
}

do // looks up the function "do" and calls it

Additionally checking the type of a value wasn’t trivial as well as the types had to be looked up by name as well.

Furthermore Lithia leverages lazy evaluation, which means that expressions are not evaluated until their value is needed. This adds additional overhead as every expression has to be wrapped in a thunk (a parameterless function).

And this makes the second problem of this clear: everything is hidden behind pointers and in general everything is kind of costly. Not necessarily in terms of complexity, its just slow like hashing strings multiple times per variable access, checking if everything has been evaluated and last but not least it can’t be cached efficiently by the CPU.

The Bytecode Interpreter

Zirric takes a different approach to this. It defines a virtual machine (VM) that executes bytecode instructions. Zirric’s VM is stack based, which is comparable for a simple calculator or a deck of cards: each operation works on the topmost elements of the stack.

The bytecode itself is separated of all constants. Instead these are in a separate array or slice while the bytecode references them by index. In case of the expression 40 + 2, the constant 40 is at index 0 and 2 is at index 1. The human readable bytecode to add these two numbers is then:

# 1 + 2
Cons 0 # Pushes the constant at index 0 (40) onto the stack
Cons 1 # Pushes the constant at index 1 (2) onto the stack
Add
# Result: 42

The actual bytecode currently looks like this: 01 00 00 01 00 01 10. Neat, huh?

The VM iterates over the bytecode instructions and executes them one by one. Here Cons loads the constant with the fitting index onto the stack. Add pops the top two elements from the stack, adds them and pushes the result back onto the stack. That way the stack of the VM grows and shrinks as needed.

When it comes to variables, the VM uses a different approach as well: each variable gets an index assigned at compile time. That way variable access is just a matter of looking up an index of a single array.

Now let’s get back to our example from above:

let a = "global" // globals[0] = constants[0]

func do() { // functions are constants: constants[1]
 let b = "local" // locals[0] = constants[2]

 print(a) // globals[0]
 print(b) // locals[0]
}

do() // constants[1]()

No more string lookups. No more parent contexts. Just direct index access. And the best part of this: the CPU can cache this data much more efficiently.

What about laziness? Almost everything is now eagerly evaluated. Expressions are evaluated as soon as they are encountered. Though there are a few exceptions like logical operators (&&, ||) which skip their right hand side if the result is already determined by the left hand side. This is common and does not add much overhead.

But in Zirric globals are still initialized lazily. More on this in a future blog post.

Why that hassle?

Interpreters are much easier to implement and to understand. Is this actually worth it?

Glad you asked! I made some micro benchmarks for Lithia and Zirric. In this case I wrote a simple recursive Fibonacci function in both languages and measured the time it takes to compute for several numbers.

Microbenchmarks can be misleading and do not reflect real world performance. But as long as we keep all tests as similar as possible, we can get a rough idea of the performance difference.

Here is the Lithia version:

func fib { n =>
 if (n < 2), n, (fib n - 1) + (fib n - 2)
}

Here is the Zirric version:

func fib(n) {
	return if n < 2 {
		n
	} else {
		fib(n-1) + fib(n-2)				
	}
}

As both languages are implemented in Go, I used the builtin Go benchmarking for both to keep it as similar as possible.

And these are the results on my machine:

Input	Repetitions	Lithia	Repetitions	Zirric	Factor
28	1	5,338 sec	1,000,000,000	0.1101 ns	4,848,486
30	1	13,990 sec	1,000,000,000	0.2860 ns	4,891,832
32	1	36,805 sec	1,000,000,000	0.7305 ns	5,038,386
40	0	(too long)	1	34,238 sec	(too long)

When I first saw these results, I had to check if I messed something up. We are comparing seconds with nanoseconds here. That’s why I added another run with fib(40) for Zirric to validate the tests. And they were right. Zirric is nearly five million times faster than Lithia in this case.

To get some more context, I also measured the Python and Ruby fib(40) and got around 10 to 17 seconds here. Although these numbers are not accurate and probably estimated too high, they give a rough idea of the performance difference. Zirric is multiple times slower than these languages, but still in the same ballpark, while Lithia is outclassed by magnitudes.

Zirric is still in early development. Through optimization, new language features but also additional safe guards the performance profile will change over time. And probably not always for the better. Also this is just a microbenchmark that is not in favor of Lithia. Real world performance might be different. Take these numbers with a grain of salt.

But yes, this was worth the hassle. In case you are curios about what’s up next or want a nerd talk, feel free to reach out to me @mastodon.social@vknabel.

Zirric: A new Beginning

Tue, 16 Sep 2025 00:00:00 +0000

After a long time of procrastination I finally resumed my work on my new programming language. Back then I wrote about the current state of Lithia and how I arrived in a dead end regarding the language design. Sure I proposed some large changes, but if a lazy evaluated programming language with a parensless call syntax becomes a strict evaluated programming language with a regular call syntax and multiple additional features, is it still the same ~~boat~~… language?

Literally every line of code would break. That’s why I decided to create a new, currently private, repository for my new programming language called zirric.

This blog post is part of a Journey about creating a new programming language.

What will zirric be like?

Similarly to Lithia, zirric will still be simple, but it will still be much more feature rich than Lithia.

First to get the boring stuff out of the way:

zirric will be dynamically but strongly typed as Lithia is.
zirric will be strict evaluated while Lithia is lazy evaluated.
The call syntax might now look slightly familiar as f(a, b) instead of f a, b.

Annotations

Regarding the type system zirric adds the new annotation types to Lithia’s data and enum types. An annotation is declared like a data type, but can be instantiated with an @ before declarations.

annotation Countable {
 @Returns(Int)
 length(@Has(Countable) value)
}

@Countable({ v -> v.length })
data Bag {
 @Array items
}

In contrast to decorators in other languages, annotations only store data. They cannot change the behavior of functions or types. To use annotations, a new reflection API will be provided.

import reflect

@Returns(Int)
func count(@Has(Countable) value) {
 return reflect.typeOf(value).annotation(Countable).length(value)
}

The effectively replaces the old but common witness pattern in Lithia with a more flexible and powerful system without introducing other new concepts like interfaces.

As you might have noticed, the new annotations can but don’t have to be used to provide type hints. In the long term these should be checked by the compiler and fuel the language server to provide better IDE support.

Control Flow

In Lithia there were no control flow constructs like if statements or for loops except the type expression. Instead everything was expressed via functions and recursion. This was slow and cumbersome.

zirric now comes with classic if and switch statements as well as for loops. if statements will support multiple branches and else if as well as inline variable declarations.

if condition {
 doSomething()
} else if otherCondition {
 doSomethingElse()
} else {
 defaultCase()
}

switch statements will support type matching as well as value matching.

switch value {
case @SomeType:
 doSomething(value)
case 42:
 doSomethingElse()
case _:
 defaultCase()
}

for loops will support iterating over ranges, arrays, maps and custom iterators and infinite loops with for { }.

for {
 if condition {
 break
 }
}

for i in Range(0, 10) {
 println(i)
}

In contrast to other languages, there will also be if, switch and for expressions that can be used inline to assign values. In there only variable declarations and one expression per branch are allowed.

let filtered = for num -> items {
 if num % 13 == 0 {
 break
 } else if num % 2 == 0 && num % 3 == 0 {
 "fizzbuzz"
 } else if num % 2 == 0 {
 "fizz"
 } else if num % 3 == 0 {
 "buzz"
 } else {
 continue
 }
}

A few more things

zirric will come with a working package manager out of the box, it will have a new design and mascot (you might have noticed) and in the long term the language server and tooling will be much better and more accurate than Lithia’s.

A much better performance is also a goal, but don’t expect miracles here. Lithia was just really slow.

What is the current state?

As of now, zirric is still in a very early stage. zirric can parse lots of the syntax although large parts are still missing. Though the execution side is still in its infancy and only supports a few basic mathematical operations, arrays, bools, and if statements and expressions. Variables and functions will be the next big step.

At the tooling side, the core of the package manager is already present.

I guess I have quite a long way to go, but I am excited to finally work on a new programming language again. If you want to follow along or want a quick chat, feel free to reach out to me @mastodon.social@vknabel.

Die Mitternachtsbibliothek

Tue, 01 Jul 2025 00:00:00 +0000

The book opens with a shocking moment. Trigger warning: themes of suicide and depression.

After that, the pace slows and the story gradually draws you in. While it may not be thrilling in the classic sense, it captivates on a different level.

It’s a moving and wondrous book, written at a cosy pace that never becomes boring. Overall, it’s still a feel-good book.

Ich, Sperling

Tue, 01 Apr 2025 00:00:00 +0000

The story is told from the perspective of a young boy in ancient Rome who grows up in a brothel.

Some intense topics are brought up and talked about. But a lot of it is left to the reader’s imagination. So, luckily, the most intense topics are left out but still talked about.

At times, while reading, you already have a premonition of what will happen in the next chapter. You feel and share the excitement. An intense book, but one of my favorites.

The Queen of Anthuriums: Warocqueanum

Sat, 25 May 2024 00:00:00 +0000

One of the most iconic species of Anthurium is undoubtedly the queen of Anthuriums: the Warocqueanum. With its long, tapering, and often dark leaves, especially adult specimens know how to make a grand impression.

The leaves of the Anthurium Warocqueanum can reach a length of over one meter. In this case, they are 65cm.

Caring for the Warocqueanum

Our queen hails from the rainforests of Colombia and naturally occurs in both the humid lowlands and highlands. This relatively broad range of altitudes makes it somewhat less demanding compared to other members of its kind. With proper care, it is undemanding and can tolerate occasional dry stress, as long as there is no new leaf or bloom on the way. It requires slightly higher humidity than other Anthuriums.

Despite its thick and robust-looking leaves, you should maintain a constant humidity level of over 50%. Otherwise, it can quickly suffer cosmetic leaf damage. Generally, the plant needs more time than usual to adjust to new conditions, so these should be kept relatively constant.

Regarding substrate, the Warocqueanum does not have extraordinary requirements for Anthuriums and can be easily kept in semi-hydroponics. As with all Anthuriums, you should use high-quality, airy substrate.

Personal Experience

Since I acquired my Warocqueanum, it has been kept under artificial light in a terrarium with humidity usually between 60 and 70%. I have had no problems with root rot or pests, even when other plants in the terrarium were affected. When the humidity dropped too much, there was often leaf damage.

The new leaves of the Warocqueanum start off in a dark green.

Most of my Anthuriums grow faster, but they usually produce smaller leaves. Over time, the Warocqueanum lives up to its name and rules the terrarium with its enormous leaves. It can’t grow much larger due to space constraints.

Once the leaves of my plant reached a size of about 40cm, it slowly started to bloom. Since I wanted to avoid the stress of seeds and flowers, and because the new leaf was more important to me, I usually removed the flowers or just collected the pollen.

Hybrids

Fortunately, the Warocqueanum belongs to the large section Cardiolonchium and thus has many potential hybrids. I don’t have larger specimens yet, but I do have a few candidates with potential.

Warocqueanum ‚Esmeralda‘ Warocqueanum ‚Esmeralda‘ x ‚Dark‘

Overview of the Philodendron Malay Gold

Sat, 10 Feb 2024 00:00:00 +0000

Featuring bright green to golden leaves with hints of red, the Philodendron Malay Gold is a classic representative of its kind – just brighter. For those who appreciate the color but not necessarily the growth form, alternatives such as Philodendron Hederaceaum ‚Lemon Lime‘ (a.k.a. Scandens) or Epipremnum Aureum ‚Neon‘ are available.

New leafs are bright and yellow.

New leaves emerge neon yellow and gradually turn greener over time, maintaining a relatively light hue. The leaf stems, especially at the base, showcase a reddish tint. The more light it receives, the more intense the coloring becomes. The leaves have rounded bases, lack the typical „ears,“ and do not grow particularly large.

Older leafs gradually darken.

Care

Like most Philodendrons, the Malay Gold is exceptionally robust. The advantage of easily assessing the lighting conditions based on new leaves provides timely feedback after relocation. While it cannot thrive in as low light conditions as some of its counterparts, it does not demand an exceptionally bright location either.

Four substantial Malay Gold plants in a single container. Fresh leaves exhibit a lighter hue and gradually darken over time

It simply wants to grow tall and fast, with an inherent upward trajectory. Although the stem is typically broader than that of a Melanochrysum, a support structure becomes necessary at a certain height. While it would likely accept a moss pole, it is not strictly necessary. Personal Experience

The Malay Gold has adorned various corners of my home: in winter on the south side, centrally located, on the east and west sides directly by the window. Maintaining humidity levels between 30% and 60%. Notably, there were no significant issues in any of these placements.

It has even stood directly next to the open balcony door in summer and fall, welcoming thrips that occasionally find their way in. While a mild infestation occurred, it caused no substantial harm. Other pests have never been a concern.

In the same pot, serving as a small contrasting companion, an Epipremnum Aureum ‚Neon‘ is thriving as a sublet. It flourishes better in this shared space than when grown alone.

Given its size, the water requirements for our plant are relatively modest. Thanks to its determination to grow upward, its space requirements are also manageable.

Propagation

It’s needless to say that propagating a Philodendron is at best a challenging task. The Malay Gold is no exception and is most effectively propagated through cuttings. The advantage lies in its ability to develop aerial roots even in moderate humidity conditions, facilitating an effortless rooting process for cuttings that swiftly establish themselves as independent plants.

My plant two years ago.

Of Velvet and Silver: the Syngonium Wendlandii

Sat, 03 Feb 2024 00:00:00 +0000

The Syngonium Wendlandii is truly something special. With its deep green, velvety leaves, a silver stripe in the middle, and a relatively compact size, it sets itself apart from its counterparts.

As an alternative, there is also the Syngonium Rayii, which, however, requires higher humidity but rewards with significantly darker leaves. A Syngonium Wendlandii on a moss pole.

The leaves themselves feel slightly velvety but also somewhat firmer. In the juvenile form, the leaves are arrow-shaped, and with age, the earlobes separate, transforming the leaf into three parts. This is not unusual for Syngoniums – here, it happens faster and more straightforwardly. However, with increasing leaf size, the silver color diminishes and thins out. The juvenile leaves are arrow-shaped, as in other young Syngoniums. The adult leaves are three-parted.

Care

With few exceptions, Syngoniums are straightforward and have no special requirements for humidity. This holds true for Wendlandii, despite its velvety leaves. Although the leaves have a silvery sheen, it doesn’t need more light than its counterparts without silver and can thrive in darker locations. Without high humidity, it won’t root into moss poles. A bamboo stake will do.

A Wendlandii outside of display cases doesn’t necessarily need a moss pole. Below 60 to 70% humidity, too few aerial roots form, risking root rot if the substrate is not airy enough. However, a stake is recommended for a beautiful growth, especially if you desire the three-parted adult leaves.

Personal Experience

My Syngonium is positioned by the east window, receiving direct morning sunlight and experiencing slightly cooler temperatures of 18 to 20°C in winter. Even during the height of summer, temperatures rarely exceed 25°C. The humidity usually hovers around 40 to 45%, occasionally dropping to 35%. In the past, I had it in a moss pole setup with humidity maintained at 60 to 70%, and it thrived.

However, the moss pole wasn’t necessary, as the plant never embraced it, often leading to overly damp substrate. Despite this, the support structure brought visible delight to the Syngonium.

In general, it proves remarkably robust, enduring various conditions under my care, and certainly does not exhibit diva-like tendencies!

Propagation

Like other Syngoniums, Wendlandii rarely blooms indoors. Thus, propagation through cuttings takes precedence. It appreciates a support for climbing.

Juvenile arrowheads are found below.

Adult leaves grace the top.

As it grows quickly, branching out from the stem and becoming bushier, pruning is a wise choice. The cutting should then root well. However, more patience is required here compared to many other Syngoniums, as root initiation often takes time.

Anthurium Gracile: Care and Propagation

Wed, 31 Jan 2024 00:00:00 +0000

Those in search of an Anthurium characterized by uncomplicated care will find success with the Anthurium Gracile, and will be rewarded by its affordable price.

The leaves of Anthurium Gracile are bright, thin, and feel somewhat leathery. In ample light, the leaf base can take on a reddish hue. Some cultivated forms also tend to show a reddish coloration on the stem.

Its compactly growing stem gives it a bushy appearance. As the leaves protrude forward and gently taper towards the tip, the plant becomes quite expansive. Unlike Pallidiflorum and similar „Long-Boys,“ creating a leaf curtain without tilting the pot becomes challenging.

The Anthurium Gracile grows compact and has long belted leaves.

Care

In comparison the Anthurium Gracile is easy to handle but requires a more aerated substrate due to its fleshy, almost orchid-like roots. This allows it to stay dry longer, reducing the risk of root rot.

Semi-hydroponics is also a trouble-free alternative to organic substrates.

The humidity can be slightly lower than for most other Anthurium species. Spider mites have not been an issue, with only a reported incidence of thrips.

Personal Experience

I cultivated my Gracile almost exclusively in display cases, maintaining humidity between 50% and 80%, and providing artificial light for 12 to 14 hours daily. Despite occasional neglect, it took just under a year to reach the second generation from seeds. During the summer, the room temperature often soared between 20 and 28°C in the evenings.

Now, it resides outside the display case and thrives even with 40% humidity.

Spider mites posed no challenge, and I only encountered a thrips infestation. Despite visible leaf damage, the impact on growth was minimal.

Inflorescence

Anthurium Gracile is highly prolific in flowering, typically producing a new bloom with each leaf. Being self-pollinating, no specific action is required for the development of red berries. The inflorescences are unusually located beneath the leaves.

The flowers of the Anthurium Gracile are unimpressive and usually grow below the leaves.

In contrast to other species, the berries ripen in just a few weeks rather than several months. Due to the low cost and high frequency of new seedlings, it’s advisable to trim the inflorescences in the long run to avoid unnecessary stress on the plant.

Crossbreeding

Belonging to the Leptanthurium section along with Vittariifolium, Anthurium Gracile has no known other species. However, successful pollination with closely related sections may occur with some luck.

Five red berries of the Anthurium Gracile. The berries of the Anthurium Gracile are red and similar sized to the seeds of a Grapefruit. It usually contains 1 or 2 seeds.

The spadix and a few berries.

The current state of Lithia after 2 years

Thu, 18 Jan 2024 00:00:00 +0000

In 2021 I started working on the current Go implementation of my own experimental programming language called Lithia. Now it is available in version v0.0.19. Infrequently I also wrote some words about it on this blog. It has been designed to be an experiment, that is able to teach some lessons and that can be fulfilled.

For a programming language being able to teach lessons, a Standard Library and of course some programs need to exist. Only the experience of its developers can lead to conclusions. Now it’s time to derive those!

This blog post is part of a Journey about creating a new programming language.

The current state

But first let’s have a look on the current state of Lithia.

Lithia has all planned features implemented. You can define data-structures, enums similar to unions, functions, constants, modules and imports, closures, partial application of parameters and lazy evaluation. The standard library currently consists of 19 modules providing base types, helpers around comparisons, strings, results and more, file system access and a micro-framework to write unit tests in and for Lithia. Every module is fully documented and is generated by a Lithia script.

To declare packages and to make project-based scripts easily accessible, there is the Potfile (comparable to package.json, Package.swift, go.mod, Gemfile & Taskfile).

Although the performance of the Lithia interpreter has largely improved in the early days but it’s still slow and leaves room for improvements.

Developing Lithia is fueled by the Visual Studio Code extension which relies on the Language Server within the Lithia binary and does not need to be installed separately. It provides syntax highlighting, diagnostics and autocompletion. Additionally to the LSP there is a tree-sitter grammar which can be used in other modern editors.

The Developer Experience

Obviously the development experience in such a young programming language doesn’t reach the ease of use of mature ones. But for a scripting it provides decent autocompletion. Though there are no formatters or linters, yet. And currently there is no debugger support, which is a bummer. In practice this at least encourages the use of unit testing.

Lithia has a dynamic but strict type system, which may lead to runtime errors, which is okay for scripting. But the mix of lazy evaluation often further delays and hides these runtime errors and make debugging unnecessarily hard. Especially when adding concurrency. This needs to change.

Another option for improvement is the current parens-less call syntax: instead of f(g(x), y) you write f g x, y. With great syntax highlighting this is something you get around, but syntax should be self-explanatory.

What’s also missing is a real package manager although git submodules at least provide a workaround for this.

Summary

In general Lithia as an experiment was successful and lead to really great results. The simplicity but power of the type system is a breeze. But Lithia needs a change. And at its core lazy evaluation needs to be dropped, while the overall tooling should evolve. But what’s still missing is the perfect use case that perfectly fits Lithia’s language features. The upcoming release v0.1.0 should provide answers and solutions for those pain points.

If you wish, check out the open source repository of Lithia. If you have any questions don’t hesitate to ask me on @mastodon.social@vknabel or join the Lithia discussions.

Happy coding!

Why Plant Care Guides on the Internet Are Bullshit

Mon, 01 Jan 2024 00:00:00 +0000

There are already many websites offering plant care tips. The articles tend to be very long but contain little relevant information.

Almost every plant is described as needing bright, indirect light and as being unable to tolerate root rot or requiring fertilisation in winter. It’s as if there are plants that like to rot away! It is often stated that houseplants need increased humidity. By how much? 50%? 80%? The exact specification is often missing.

Oh, and by the way… This beautiful plant is the perfect starter plant for you. It only costs $50 and will attract spider mites if it is not cared for properly. Completely altruistic, of course. Shops and websites with affiliate links or advertising are simply not reliable or independent sources.

For example, a Philodendron Gloriosum is prone to spider mites when humidity is too low.

What matters?

Every plant is unique and grows in a unique environment: yours. Every tip for caring for a plant comes from someone with different watering habits, substrate and lighting conditions. Humidity, air circulation, temperature and fertilisation can all be different, too. Even the water probably has a completely different hardness level.

Various cuttings in water: Philodendron Brandtianum & Birkin, Monstera Adansonii ‘Swedish Ghost’, Rhapidophora Tetrasperma, Epipremnum Cebu Blue and an Anthurium Rubrinervium.

This makes it impossible to make suggestions that are applicable everywhere—or that make sense. That’s why you see the same information everywhere. Nevertheless, there are differences. These must be pointed out.

How we’re different

Rather than resorting to the same old clichés, we compare different plants and assume that you already have some. No bullshit.

Read our care tips for anthuriums and compare them with other arum plants, such as alocasias and philodendrons. We also provide profiles or portraits of individual species for comparison.

Philodendron billietiae on a climbing stick.

For example, let’s compare Anthurium gracile with other anthuriums. If you already have experience of caring for anthuriums, we only need to briefly address their special features. This will also give you a quick overview of the plant.

Most species grow differently and can be displayed in various ways. If a plant has an unusual growth habit, we will mention that, too.

For example, an Anthurium gracile with burns on its leaves.

We only write about our own plants, not random or trendy ones. If the plant has a yellow leaf, this will be included in the photo. There will be content about common plants, as well as lesser-known plants and individual hybrids.

Anthurium Veitchii Jungpflanze Anthurium Besseae aff Anthurium Villenaorum x Besseae

24hrs format for html inputs in Firefox

Thu, 09 Nov 2023 00:00:00 +0000

My system language on my linux machine is set to English, but as a German raised with 24-hour days, I simply cannot wrap my head around to get the 12-hours am/pm format intuitively. By the time I learned that am is in the morning and pm is in the evening. But when it comes to 12:00 as the mid of the day and 0:00 in the night, I’m lost.

Of course I have already set the time format to 24-hours in my system settings (Ubuntu Date & Time > Time Format set to 24-hour), but Firefox still uses the 12-hours format for html inputs with type="time".

As a solution you open about:config and set intl.regional_prefs.use_os_locales to true. Now simple <input type="time"> will use the 24h format!

My Personal View on Acorn

Mon, 12 Dec 2022 00:00:00 +0000

Acorn is an application deployment framework for k8s, that tries to simplify instead of introducing another layer of indirection. I won’t cover all details and problems it tries to solve here, instead I’d like to share some experiences and thoughts.

Acorn has been discontinued and they are now doing some AI slop stuff.

My experience with Acorn and Kubernetes

Before we dive right in, I’d like to let you know about my level of experience with Kubernetes and Acorn.

I started having a look on Acorn in August 2022 and played around with it. I did not have production experience with Kubernetes, but I started learning and playing around with it a few months before.

To get a deeper understanding on k8s, I soon started to migrate my personal services hosted on multiple docker-compose-files. Later I had a look on Acorn and started to play around with it. I also translated my docker-compose-files and k8s manifests to Acorn and liked the result.

Later I migrated my personal production services to k8s and Acorn. As Puffery only has a few users, there wasn’t much risk involved.

On October 2022, I held a talk about Acorn at the Kubernetes Community Days Munich 2022. And recently I wrote the corresponding blog post for my employer’s blog to share the contents of the talk.

Secrets

Acorn forces you to declare secrets in the Acornfile, but it forbids you to provide them there. Instead it will automatically generate the secrets on the initial deployment. You don’t have to worry about secrets anymore.

The weird part is, when you have an existing secret. You don’t override or change the generated secret. Instead you create a new secret at the command line and link both secrets together.

But if you are used to it, it’s actually a nice way to solve this issue.

Referencing Resources

In Acorn you need to reference some resources like a specific secret or volume. Here you use an URL with the appropriate scheme. For example, to reference a secret, you use the secret:// scheme.

In regards to volumes, this is awesome, as you can even mount a specific path of the volume into a directory. But when using secrets, this is sometimes a bit annoying, as you need to reference the whole secret and then extract the value you need, like secret://db-password/token. The benefit: you can create a secret to mount multiple files into a container using an opaque secret.

I understand the reasoning behind using resource URLs, as these resources technically need to be created and are not part of the Acorn Image. But in the beginning this was a bit confusing. Maybe this is just a documentation issue.

Development

For development we always need a vast range of tools. Especially when working with multiple programming languages. I tend to avoid installing those on my local machine and instead use containers. In easier cases I use Remote Containers for VS Code. For more complex use cases that include databases, I rely on docker-compose. But if the application needs to run in a Kubernetes cluster, it would be twice the work to maintain the docker-compose.yaml and the k8s manifests. With Acorn, I can use the same manifests for development and production. Of course I need to sprinkle some if statements in the Acornfile to make it work for both environments, but it feels much more natural than maintaining two different sets of manifests.

And to be honest, I think an Acornfile is far easier to read, than a docker-compose.yaml or many k8s manifests.

Production Use

I have been using Acorn in production for a few months now and I have not encountered any problems so far. Instead I really like gathering all logs of one application with a single command out of the box: acorn logs [app].

I also like the fact, that Acorn knows the concept of an app. That way it can provide a great overview about whole applications across multiple resource types.

Conclusion

I really like Acorn and I think it’s a great tool to simplify the deployment of applications to Kubernetes. It’s not perfect, but it’s a great start. At the moment I’m not sure if I would use it for a production application with a lot of users, but I would definitely use it for my personal projects.

Statically read files with go:embed

Thu, 18 Aug 2022 00:00:00 +0000

Did you ever want to access the contents of an auxiliary file from within your repository to access the contents at runtime? This file could include some static settings like the version of the application, translations for user-facing texts, GraphQL requests or SQL queries. The typical solution to this problem is shipping your binary with the auxiliary files.

But this solution comes with great costs. You cannot ship one single executable anymore. Those files need to sit somewhere in the filesystem. And they might be misplaced, outdated or even missing.

Thankfully there is a library and language feature introduced in Go 1.16 that allows you to embed files statically into your binary.

You can download this example project or jump directly to the source code on Github.

Let’s go:embed the license file

For now we want to start easy by embedding the contents a single file. In this case we wish to set our license to the contents of our LICENSE file.

To get started, we need to import the embed package. As we won’t use any member of the embed package for now, we place an underscore before the package. This imports embed solely for its side-effects. Otherwise go fmt would directly erase the import statement.

import _ "embed"

Now let’s create a new variable license and assign the contents of the LICENSE file to it. We simply initialize the variable by using the go:embed compiler directive.

//go:embed LICENSE
var license string

And that’s it. If we mistype the file name, we get an error. If we forget to import the embed package, we get a warning. But there may be no space between in //go:embed like in normal comments.

Note: embedding file contents only works for global variables, not for locals.

To actually understand how powerful this feature is, let’s write a test by manually reading the file and comparing both.

func TestEmbedsLicenseFile(t *testing.T) {
	// as usual, read the file
	bytes, err := os.ReadFile("LICENSE")
	// check for errors
	if err != nil {
		t.Fatal(err)
	}
	// convert to string
	want := string(bytes)
	// actually use the contents
	if diff := cmp.Diff(want, license); diff != "" {
		t.Errorf("unexpected license (-want +got):\n%s", diff)
	}
}

In this example, we declared the variable as string, but in other cases you might want to use []byte. For example if you want to pin the signature of a remote certificate.

go:embed the file system

In our previous example, we included a very special file that is unique in our repository. But sometimes we have many files, which should all be included in our binary.

In this case we are going to embed our docs folder within our app. We don’t want our users to be forced to leave. Instead we want them to be able to explore and access the docs directly from within our app.

In this case we are going to create an embedded file system.

import "embed"

//go:embed docs
var docsFS embed.FS

embed.FS conforms to fs.FS and as with all fs.FS, we can read directory and file contents. The usage is pretty straightforward. So let’s write a test which checks if the contents of the embedded docs folder are equal to the contents of the docs folder in our repository.

func TestEmbedsDocs(t *testing.T) {
	dirFS := os.DirFS(".")

	// get all files within the docs directory
	gotEntries, err := fs.ReadDir(docsFS, "docs")
	if err != nil {
		t.Fatal(err)
	}
	wantEntries, err := fs.ReadDir(dirFS, "docs")
	if err != nil {
		t.Fatal(err)
	}
	if len(gotEntries) != len(wantEntries) {
		t.Errorf("got %d entries, want %d", len(gotEntries), len(wantEntries))
	}
	for i := range wantEntries {
		if diff := cmp.Diff(gotEntries[i].Name(), wantEntries[i].Name()); diff != "" {
			t.Errorf("unexpected entry (-want +got):\n%s", diff)
		}

		// read the files
		got, err := fs.ReadFile(docsFS, "docs/"+gotEntries[i].Name())
		if err != nil {
			t.Error(err)
		}
		want, err := fs.ReadFile(dirFS, "docs/"+wantEntries[i].Name())
		if err != nil {
			t.Error(err)
		}
		if diff := cmp.Diff(got, want); diff != "" {
			t.Errorf("unexpected contents (-want +got):\n%s", diff)
		}
	}
}

This unit test is probably a bit too much, but it’s always a good idea to ensure the embedded contents are valid. Are they valid json? Not empty? Do certain files exist?

Huh? No magic? Yep. As you can see in the test above, the acutal file system and the embedded file system are used exactly the same. There are no real differences when using the readonly fs.FS. But here’s the difference. Nobody guarantees that the files in the os file system has not been tampered with. Or if it has been set up correctly in the expected path. The compiler proves that those files are accessible.

Another benefit: you decide which files you want to embed. Are you only interested in markdown files? Use //go:embed docs/*.md.

Let’s add another file: the README.md.

//go:embed README.md
//go:embed docs
var docsFS embed.FS

Yep, that’s it. We simply add another //go:embed directive. But how do we know if both directives are respected? Correct, by writing a quick test!

func TestEmbedsReadme(t *testing.T) {
	// read using the ReadFile method
	got, err := docsFS.ReadFile("README.md")
	if err != nil {
		t.Fatal(err)
	}
	// as os has, too
	want, err := os.ReadFile("README.md")
	if err != nil {
		t.Fatal(err)
	}
	if diff := cmp.Diff(got, want); diff != "" {
		t.Errorf("unexpected README (-want +got):\n%s", diff)
	}
}

Summary

go:embed bundles files and directories into the binary at compile-time. Of course you shouldn’t embed all files and blow up your binary size, but it can greatly simplify your deployment process and prove that auxiliary files are accessible and immutable.

Curious about more use cases? Here is a non-exhaustive list to get started:

injecting the version of your software
pinning the signature of a remote certificate
embedding documentation
linking against an environment (prod, staging, …)
translations / localizations
GraphQL requests
SQL queries
snapshot testing (e.g. for integration tests)
for loading defaults
…

Atomic Design

Wed, 17 Aug 2022 00:00:00 +0000

Today I stumbled upon Atomic Design. It is some kind of architectural pattern for the user interface. The goal is to build a reusable UI that is easy to understand and maintain.

It starts with atoms, which represent the smallest units of the UI like text, buttons or images. By composing atoms, you get molecules like a search input (label, input, button). Then there are organisms like the top navigation bar. Templates align organisms. In the end, Pages fill the templates with acutal data.

From my perspective, only the Pages connect to non-UI parts of the application. Hence the Atomic Design is only focused about the structure of the view.

Open Policy Agent

Mon, 15 Aug 2022 00:00:00 +0000

With OPA you implement decisions of policies, not their enforcement. This avoids confusion between multiple servers that might come from different implementations of the policies.

The decisions themselves are implemented using the Regi programming language.

Similar to Prolog, Rego is a declarative and logic programming language. A seldom choice, but a great fit for policies!

Overriding Go values with ldflags

Fri, 12 Aug 2022 00:00:00 +0000

You can override Go values with ldflags during the build.

That way, you can inject values like the current version, build date or the current commit hash.

go build \
 -ldflags "-X 'github.com/metal-stack/v.Version=$(VERSION)' \
 -X 'github.com/metal-stack/v.Revision=$(GITVERSION)' \
 -X 'github.com/metal-stack/v.GitSHA1=$(SHA)' \
 -X 'github.com/metal-stack/v.BuildDate=$(BUILDDATE)'" \

Seen in the metal-stack/v repository.

Kubernetes without Load Balancers?

Sat, 06 Aug 2022 00:00:00 +0000

All the hosted Kubernetes solutions I know of want you to pay roughly 10$ pre month for each load balancer.

If you currently don’t expect much traffic, but want to play around with k8s or if many docker-compose files don’t fit your needs anymore, this easily doubles your costs.

Downey.io – save money and skip the kubernetes load balancer

Bonus learning: I didn’t heard of the DaemonSet until now!

Kind is the new minikube

Fri, 05 Aug 2022 00:00:00 +0000

I have been playing around with minikube for quite some time now. Though as I run minikube on my Mac, I experienced multiple bugs regarding accessing the cluster and it’s published ports.

From my perspective Kind works much better, is faster, more stable on macOS and allows the creation of multiple clusters. Though it is not bug-free on macOS. Although most bugs seem to be related to Docker itself on the Mac.

You can even pause the cluster - just pause it’s docker container.

Bash scripts with Gum

Wed, 03 Aug 2022 00:00:00 +0000

I gave the newest tool of Charm Gum a try. It allows to create interactive bash scripts in just a few lines of code.

In my case I gave it a try for Kubernetes. I often want to look at the logs of a pod, but the exact k8s pod differs from time to time. And sometimes I forget the exact namespace or the pod’s name includes random characters.

#! /bin/bash

# let the user select a namespace
NAMESPACE=$(kubectl get namespaces -o name | gum choose | cut -d/ -f2)
# let the user select a pod of the namespace
POD=$(kubectl get pods -n "$NAMESPACE" | tail -n +2 | gum choose | cut -d' ' -f1)
# if you want to repeat, copy the command
echo "> kubectl logs -n \"$NAMESPACE\" \"$POD\""
# print the logs
kubectl logs -n "$NAMESPACE" "$POD"

Go 1.19 new Garbage Collection Memory Limit

Sat, 30 Jul 2022 00:00:00 +0000

Go 1.19 introduced a new option to customize the runtime Garbage Collection behavior: Memory Limit. This might be interesting when embedding Go within a mobile application.

Go Time – Episode #240: What’s new in Go 1.19

Announcing Puffery for macOS and the command line

Fri, 29 Jul 2022 00:00:00 +0000

Two years ago, I created Puffery for iOS, which allows sending push notifications to your iOS devices.

You can follow other’s channels and directly receive updates. There is no algorithm that decides wether you should receive notifications or not.

From the beginning scripting is part of puffery’s DNA: you were able to send messages with Siri Shortcuts and a simple curl command.

If you want to take a deeper look, feel free to check out the GitHub repository including the Swift Server written in Vapor, and the iOS app built with SwiftUI in a single mono-repo.

Puffery for macOS

If you do no share your channels, sending and receiving messages and thus push notifications from the same iOS device is kind of useless in the long run.

Some of your most productive time of the day, you are probably sitting in front of your Mac. And a macOS app better integrates into your daily workflow.

Of course, you can use your Shortcuts from your iOS device. But what’s special on macOS is the ability to pin specific workflows to the dock or the status bar. Even adding workflows to your share menus is possible!

No need to open Puffery directly if you don’t want to. No distractions.

If you are a user of macOS widgets, you are covered, too! They work exactly the same way as on iOS.

Puffery for the command line

With the next announcement, we are slowly moving outside of the Apple ecosystem. Puffery is now available as a command line tool. Currently it has a limited scope and has not yet received feature parity with the iOS or macOS apps, but it does not only support macOS, but also Linux and Windows.

It provides a tui / text based interface to scroll through lists of channels and messages. You can also send messages to a previously selected channel.

You can even signup or login with your existing account.

To give it a try, have a look on the puffery installation instructions.

It has been built in Go and Charm’s Bubble Tea library. As all of Puffery, it is open source and licensed under the MIT license.

Extracting Tailwind constants using theme

Mon, 25 Jul 2022 00:00:00 +0000

When using tailwind, you might be forced to manually write SCSS by hand. With @apply some classes; you can embed whole classes with all their styles into your own rules.

But sometimes you need to only acces one single constant. Like accessing an animation timeout, default paddings, fonts or a color for some cases.

That’s possible with a simple theme('colors.primary').

Hugo Assets placed in Folders

Sun, 24 Jul 2022 00:00:00 +0000

If you need assets for a specific document or blog post, you can simply create a folder with your desired name and place your assets in there. Rename the markdown file to index.md.

To reference the asset, just link it relative to the folder [text](./my-file.ext).

Hugo's Syntax Highlighting is static

Sun, 24 Jul 2022 00:00:00 +0000

Unlinke many other static site generators, the syntax highlighting of Hugo does not use client-side JavaScript, which is great!

The underlying library is available as Go module github.com/alecthomas/chroma.

Overriding internal Hugo templates

Sun, 24 Jul 2022 00:00:00 +0000

You can override internal Hugo templates with your own templates.

Simply create it in the layouts folder and you are done!

That’s how I overrode _internal/google_analytics_async.html with my own template - to not use GA! That way I could avoid forking athul’s archie template.

Templates for specific folders in Hugo

Sun, 24 Jul 2022 00:00:00 +0000

In Hugo you can simply create a folder within content/ and a template within layouts/_default/. It will be used for the index route of that folder - even if your template did not specify a layout.

This allowed me to create a separate template for all my learnings / til section!

Ultra-fast Hugo GitHub actions

Sun, 24 Jul 2022 00:00:00 +0000

I created a GitHub workflow to automatically build and deploy my website to GitHub Pages.

It uses peaceiris/actions-hugo@v2 to build the website with Hugo and peaceiris/actions-gh-pages@v3 to deploy it to GitHub Pages.

About

Fri, 22 Jul 2022 00:00:00 +0000

I’m Valentin Knabel, a developer, a cyclist, coffee nerd, vegan and a human. When possible I prefer real-world stuff, open source and privacy.

I value simplicity, kindness and honesty. It is fine to be imperfect, as long as we are honest and have fun along the way.

Usually I am @vknabel everywhere like on GitHub and @mastodon.social@vknabel

I work at x-cellent on metal-stack.

Curious for more?

If you want to dig deeper into my thoughts, priorities and projects, feel free to check out the following pages:

Now - describes my priorities and what’s on my mind and what I’m currently working on.
Colophon - how this website is built and what tools and technologies I use to build it.
Projects - a list of projects I maintain or regularly contribute to.
Sovereignty - my current progress towards digital sovereignty using European services or self-hosted software.

Designing and scoping my programming language Lithia

Fri, 22 Jul 2022 00:00:00 +0000

Once you have decided you want to create your own programming language, you need to create a broader concept. Every programming language is unique in its own way. Your goal is to find out in which way. And you need to find your reason why you want to create it in the first place.

Do you want to solve a particular problem?
Is it for learning purposes?
For who do you build the language?
Who should use it?

Keep the answers in mind during the whole design process: they will guide you into the right direction.

In my case, I designed Lithia for myself to learn and explore all sorts of tooling around programming and to create them myself. And that’s also the focus of the language: tooling around itself. Learning by doing is king here.

This blog post is part of a Journey about creating a new programming language.

My initial take on designing Lithia

I really like functional programming, but I value being able to perform changes imperatively when I need to. I like the idea of lazy evaluation and being able to create infinite data structures, but to only execute needed parts. And the stronger your type system is, the more errors can be caught at compile time. Some downsides like verbosity can be reduced by type inference.

Writing functional algorithms really work well with enumerations where every case may have attributes or associated values. It should also be possible to add scoped methods to already declared classes or data types.

And generics are great, let‘s stuff generics in there. Great nice language. How long will I take to implement it? Well…, scrap that.

Let‘s start all over.

Every programming language special on its own way. To define each characteristic of it, you not only need to know the language features, but the intentionally missing ones, naming conventions, typical patterns, the standard library and how everything is tied together.

That all defines the programming language. Everything is a tradeoff. For example, every piece of syntactic sugar makes your language more expressive, but harder to read. Every new feature needs to be learned and understood correctly. And every feature may be used in the wrong places or not at all.

What language is worth to implement?

Let‘s be honest: programming languages tend to be on the bigger side of projects and we all have limited time, energy and motivation. And there are plenty of programming languages out there.

Where does your language fit between all those other already finished languages? Are you solving niche problems? Are you experimenting with new language concepts or are you mixing seemingly unrelated paradigms? And more importantly: why do you want to implement it yourself? Are you able to even finish it? How do you keep your motivation up in the long term?

If you decided to start working on a compiler or interpreter, be sure to be able to finish it and expect you will be the only one using it.

So what‘s my case? Lithia does not solve a particular problem, but it enables me to learn about the inner workings of compilers, interpreters and the tooling around it. I want a green field to build all kinds of tooling. And in case there is a limitation or bug, I can fix or embrace and document it. What can be achieved in a specific field is not limited by external factors, only by my time, energy and motivation.

It’s about the scope and milestones

We know, the planned Lithia is not going to be able to compete with whole language ecosystems or programming languages that shine through lots of features. I wouldn’t be able to finish it.

Instead, the scope must be reduced. Even more as the language should be accompanied by tooling, coming with a huge scope increase!

But great tooling requires meta data like types to operate on and the compiler needs to support all that.

There need to be compromises.

And I need continuous wins to keep my motivation high. Once there is a basic implementation, I want to do some simple stuff, while working on a complex subsystem.

Lithia needs to shine through the absence of many features. Instead it should focus on few key concepts, that support requirements for tooling. And after all, it should be a language I like to program in.

To sum up, Lithia…

is a simple language with only a few features
supports tooling
allows a few quick wins
is conceptually attracting

Lithia is an experiment

I personally prefer mostly functional programming languages with a shot of imperative programming. In that context I also favour lazy over strict evaluation and love currying.

Lazy vs strict evaluation: expressions will only be evaluated if their value is actually needed in lazy evaluation. With strict evaluation they will always be evaluated.

Currying: let’s imagine you have a function with two parameters, but you currently have just the first parameter. With currying you can pass just the first one and you will receive a function that accepts the second parameter. Without currying you‘d need to manually create that function.

Lithia won’t allow direct mutations of variables. There will only be constants. I didn’t want to explicitly forbid any mutations, but at this stage I didn’t know how they fit into the language, yet.

Why? lazy evaluation and directly mutating variables might lead to weird behaviour. And what about types of a variable? May they change at any time?

The type system should be easy to bootstrap, but should enable static analysis in the future.

That’s my baseline.

Type System

Variables, parameters and functions won’t have an explicit type annotation like Java’s String name, Swift’s let name: String or Go’s var name string. If there would be type annotations, Lithia would need to enforce them right from the beginning.

Instead Lithia should have an easy to bootstrap dynamic type system, that still enables static analysis. The easiest way is not to allow structural manipulation of types.

How far can we get with type inference?

Base Types

There are two basic kinds of types to support:

types like classes and structs with independent properties.
types like enums that list all possible values. In some languages enums may have associated properties, thus mixing sum and product types.

Another aspect are reference and value types and semantics. How should changes propagate through the different parts of your program?

In Lithia there will be one type with properties called data without any inheritance or methods like classes have. They will have a list of untyped properties.

Don’t worry if upcoming code snippets look unfamiliar – we will cover the syntax in another article.

data Example {
 firstProperty
 secondProperty
}

But here is an optimisation for tooling: if you want to store a function within your data, you can add all its parameters firstProperty param, and, more. When the tooling and the compiler mature, they can detect errors and improve autocompletion.

In Lithia, the enum type breaks with common interpretations. Here an enum isn’t a direct list of possible values, but a list of possible types, called a union.

This change from individual values to more generic types should make the currently rather static language feel more dynamic and like a scripting language for lovers of strong typing.

The type switch

Now that we have enums, we need to resolve those types. A type switch maps every type to a function. It requires the enum definition and returns a function that receives the value.

let increaseOptional = type Optional {
 Some: { some => some.value + 1 },
 None: { none => none }
}
increaseOptional (Some 1)
increaseOptional None

The goal is to provide functions to work on the enums within one module, that are reusable and higher level. This should reduce the amount of external type switches.

Standard Library

The stdlib is a great place to get quick wins from once the most basic implementation of the language has been finished.

In Lithia the interpreter’s responsibility ends early. It defines Strings, Characters, numeric types, Functions and some more basic types.

The Standard Library called prelude starts with famous types like Boolean and List.

In here there are many possibilities:

Testing
Docs generation
Sorting
All kinds of basic data manipulations
And much, much more!

What didn’t make it to Lithia

The list of all features that did not find any place in Lithia is longer than what did. All have their particular reasons and their absence fit into the concept of Lithia. Here are some honorable mentions:

Interfaces / protocols
Extensions / adding new methods to existing types
Methods
Type casts and direct type testing
Custom operators
Overloading
Variational arguments
Exceptions

Summary

In this post, I summarised my take on creating your own programming language. Don’t do it for glory, do it for yourself and the experience you gain.

Design your scope and concept. Make sure you stay motivated until the end. Don’t hesitate to reevaluate your decisions. Take tiny steps.

If you wish, check out the open source repository of Lithia. If you have any questions don’t hesitate to ask me on @mastodon.social@vknabel or join the Lithia discussions.

Happy coding!

Starting the journey about creating a new programming language

Fri, 22 Jul 2022 00:00:00 +0000

This is planned to be a series of blog posts about designing and developing my own programming language, where I want to share some pitfalls, my learnings, design decisions, experience and the development process.

While this series will not teach you how to write your first own programming language on its own, it might be supplementary.

After years of playing with the idea of writing my own programming language, I finally started. In the past I read books and blog posts about creating my own compiler, and I actually have written some parsers, but I never implemented the whole language itself. I know some theory, but I do not know how to actually apply it in practice.

I felt stuck between theory and simple proof of concept implementations like creating another Lisp.

What’s in this series?

These are all finished blog posts so far.

My motivations and background

As soon as I learned programming, I was inspired by all the tooling like linters, editors and the compiler itself. All developed in order to develop. They were those magical blackboxes, that felt beyond everything I could achieve.

Later I played around with various language features and writing my own standard library replacement for existing languages. Lots of fun, but not productive.

With the years, I learned new paradigms like object orientation, logical, constraint and functional programming. And beyond those big paradigms, there are many different concepts that define the languages character like the module system, dependencies, inheritance, generics, operator overloading, interfaces, type classes, strong or weak typing, dynamic or static, side-effects, monads and many more.

I started experimenting with new programming language concepts, mixing a few and thinking about the consequences. How do these features integrate and what does it mean for a different group of features? And which syntax do you need to support the special characteristics?

For fun, I worked on small libraries and tooling in existing programming language ecosystems. Nothing special or widespread. I read about compilers and interpreters and even though I implemented small lisp-like languages and custom parsers, I felt like I couldn’t write a compiler on my own.

I kept the wish to design and create my own programming language from ground up. With tooling. I want to learn every aspect of it. Run into problems. Solve them and gradually increase the maturity of the language, the tooling and the compiler.

That being said, I don’t want my language to be used in wild, heck I encourage you to not use it. The journey and what we learn along the way is the treasure.

Summary

I decided to create yet another programming language and let’s be honest: nobody will ever use it and I’m fine with it. But anyway I will still provide tooling and documentation for it.

I will update and link all my compiler and language design blog posts here.

If you wish, check out the open source repository of Lithia. If you have any questions don’t hesitate to ask me on @mastodon.social@vknabel or join the Lithia disussions.

Happy coding!

Angular *ngFor trackBy

Tue, 19 Jul 2022 00:00:00 +0000

When iterating over an array of objects in Angular, the change detection compares the references of the objects to detect changes.

If the object reference now change too, like when updating local data from the network, Angular will discard the identity of all nested components within the ngFor and re-render the entire list. Even if the objects deeply equal, the change detection will still detect the change.

To help our loop caching components and instead changing their inputs, we can add a trackBy function to the ngFor directive.

<div
 class="checkbox-row"
 *ngFor="let option of field.options; trackBy: fieldOptionTrackBy"
></div>

And in TypeScript, we add identity tracking function:

fieldOptionTrackBy(index: number, option: AssistantStepOption): string {
 return option.identifier;
}

Background: Angular did reset my mat-checkbox within the ngFor. That lead to a discard of the freshly changed values.

Go Data Race Detector

Sat, 09 Jul 2022 00:00:00 +0000

You can run your Go program or your tests with the Data Race detection enabled. This might cost some performance and memory, but in case a data race is being detected, that’s worth it!

Perfect for your CI!

go run --race ./cmd/app
go test --race ./...

Kubernetes Overview for Beginners

Wed, 25 May 2022 00:00:00 +0000

I have never done anything productive with Kubernetes before. But it is a really tough topic to get started with. It’s overwhelming.

Luckily I found an excellent Kubernetes tutorial on Youtube.

I made some personal notes while watching. Mostly to keep some overview for all the different concepts.

Today I haven’t finished the video, so the overview is only a rough draft. Some missing concepts are Storage Classes, Ingress Controllers and more!

Kubernetes Concepts

a Pod is an abstraction of usually one container.
all IP addresses are assigned and changed with every restart
Pods communicate using Services
External Services are accessible by IP and port
Ingress is used for external access using domains
A ConfigMap holds configuration data. Changing the config map prevents whole rebuilds and redeploys of specifc pods
Secrets are like ConfigMaps, but for sensitive data. Values are by default base64 encoded in the YAML.
Volumes connect storage (local or remote) to a Pod
Kubernetes does not handle storage!
LoadBalancers are a type of Services
Replicas are the amount of Deployments.
Deployments are blueprints for Pods

StatefulSets are like Deployments, but stateful.

They are designed to databases etc to avoid data inconsistency.
Harder to get right than a simple Deployment.
Databases are often deployed outside the cluster.

StatefulSet has volume claim templates, to create independent storage for each replica.

volumeClaimTemplates create a volume claim for each replica.

Kubernetes Architecture

Master nodes and worker nodes are kept separate to keep the cluster controllable. Imagine you couldn’t manage your cluster to increase the number of worker nodes or replicas.

Worker Nodes Runs multiple pods.

3 processes are running on each node:

container runtime
the Kubelet connects container runtime and the configuration
the kube proxy routes requests to services)

Master Nodes Manage the worker nodes.

Runs 4 processes:

Api Server / cluster gateway / authentication
the Scheduler that decides which worker node gets workload
Controller Manager observes the state of the cluster and makes changes
etcd is a Key-Value-Store for k8n

Iterating over a map in Go

Tue, 17 May 2022 00:00:00 +0000

Iterating over a map in Go is not predictable. This is a design decision to avoid relying on memory layout.

for k, v := range map {
 // always prints different results!
 fmt.Printf("%s: %s\n", k, v)
}

NSDataAsset reduces Code signing overhead

Tue, 03 May 2022 00:00:00 +0000

I had completely forgotten about NSDataAsset. Maybe I should move some of my JSON files into asset catalogs. According to @emergetools that should remove some code signing overhead from the app size.

Tweet by @simonbs

Attaching to UIScrollView's parent with Auto Layout

Fri, 25 Mar 2022 00:00:00 +0000

When using auto layout with a UIScrollView, subviews may not attach to the top edge of the scroll view’s parent. Else you cannot scroll, but the handle shrinks the more you scroll.

Setting left and right is ok to fix the width if you do not plan to scroll horizontally.

SwiftPM can detect breaking api changes

Thu, 17 Mar 2022 00:00:00 +0000

Starting with Swift 5.6 the Swift Package Manager can automatically detect Breaking API changes. Really great for libs!

https://twitter.com/fabianfett/status/1504393754412822530?s=12

Missing Async XCTests on Linux

Sat, 26 Feb 2022 00:00:00 +0000

Async tests do not work on Linux, only on macOS. Instead you need to implement a helper function that runs the test async by relying on expectations.

https://www.swiftbysundell.com/articles/unit-testing-code-that-uses-async-await/

WKWebView Configuration Cookies not working

Mon, 21 Feb 2022 00:00:00 +0000

Cookies in WKWebView are broken. When manually setting a Cookie using the Configuration, it will be ignored by the web view.

Workaround: add a UserScript with the following code:

document.cookies = 'cookie_optin=essential:1|analytics:0'

That’s a great way to automatically reject Cookies and especially to disable tracking to either propagate the user’s ATT decision or to avoid implementing ATT in the beginning.

Getting your IP address

Mon, 14 Feb 2022 20:53:32 +0000

Sometimes you need your local IP address on the command line to automatically pass it to a script.

ifconfig en0 |awk '/inet / {print $2; }'

Swift custom table of contents lib

Thu, 10 Feb 2022 00:00:00 +0000

If the default Table Of Contents / Index Set for iOS does not fit your use cases. This library might be interesting:

https://iosexample.com/table-of-contents-selector-built-with-swift/

Debugging Swift in VS Code in 2022

Tue, 08 Feb 2022 00:00:00 +0000

Back in 2019 I wrote an article about how to debug your Swift Package Manager projects in Visual Studio Code. In late december 2021, the Swift Server Working group released a brand new extension for vscode, which dramatically improves debugging your Swift code. Especially for linux! Time for an update!

Running, debugging and developing your targets in Visual Studio Code is not prepared by default. Especially for us Swift developers this might come unexpected, especially in comparison to Xcode. In VS Code we require extensions and configs for this purpose.

First we need to install the mentioned extension: Swift for Visual Studio Code.

Now let’s create a new project on open it in VS Code!

$ swift package init --type executable
Creating executable package: MyProject
Creating Package.swift
Creating README.md
Creating .gitignore
Creating Sources/
Creating Sources/MyProject/main.swift
Creating Tests/
Creating Tests/MyProjectTests/
Creating Tests/MyProjectTests/MyProjectTests.swift

$ code . # if not found: open -a "Visual Studio Code" .

The Swift extension for VS Code will now generate some launch configurations within a .vscode/launch.json file. It generates release and debug LLDB-launch-configurations for each target and one launch configuration for each test target. Previously this step would have been manual.

As we currently have one target MyProject and one test target MyProjectTests, we will have the following launch configurations:

Also note, that the preLaunchTasks have been created, too!

{
 "configurations": [
 {
 "type": "lldb",
 "request": "launch",
 "name": "Debug MyProject",
 "program": "${workspaceFolder:MyProject}/.build/debug/MyProject",
 "args": [],
 "cwd": "${workspaceFolder:MyProject}",
 "preLaunchTask": "swift: Build Debug MyProject"
 },
 {
 "type": "lldb",
 "request": "launch",
 "name": "Release MyProject",
 "program": "${workspaceFolder:MyProject}/.build/release/MyProject",
 "args": [],
 "cwd": "${workspaceFolder:MyProject}",
 "preLaunchTask": "swift: Build Release MyProject"
 },
 {
 "type": "lldb",
 "request": "launch",
 "name": "Test MyProject",
 "program": "/Applications/Xcode.app/Contents/Developer/usr/bin/xctest",
 "args": [".build/debug/MyProjectPackageTests.xctest"],
 "cwd": "${workspaceFolder:MyProject}",
 "preLaunchTask": "swift: Build All"
 }
 ]
}

Now we are ready to start debugging! Let’s open Sources/MyProject/main.swift, and add a breakpoint before executing print("Hello, world!") by left-clicking the empty space before the line number.

Next, switch to the Run and Debug tab on the left, make sure Debug MyProject is selected, and click the green run button.

Now your project will be compiled, run and stops at the breakpoint!

Sadly this approach currently does not work when debugging iOS or macOS apps, but Swift Package Manager projects and CLIs work great! I hope you enjoy your increased productivity!

UINavigationBar black after Xcode 13 upgrade

Fri, 19 Nov 2021 00:00:00 +0000

In case your UINavigationBar has been set to a custom color and the navigation bar is not translucent, you will experience a visual regression when updating to Xcode 13. The navigation bar background will be black - until you start scrolling. Then it behaves as expected.

Thankfully there is a workaround and an easy fix: Apple Developer Forums: barTintColor not working in iOS 15

Reminder: websites contain weird characters

Tue, 16 Nov 2021 00:00:00 +0000

Copying contents from the web often copies weird characters, like the invisible character U+FEFF or “Zero Width No-Break Space”.

Code editors like VS Code might highlight those characters depending on your config, but other websites don’t. In my case I copied a secret for my CI pipeline including the invisible character.

An easy workaround for this on the mac: Spotlight removes some of these characters. A simple cmd+space, cmd+v, cmd+a, cmd+c and esc cleans the copied text.

And suddenly the inserted password is correct!

There is a modular version manager: asdf!

Tue, 16 Nov 2021 00:00:00 +0000

Today I learned about asdf, which is a pluggable version manager.

Previously I used nvm, rvm, swiftenv and more. I now use asdf. Just add the plugin of your choice and install your desired versions.

The only drawback is installing completely new versions of the tools. You are only able to install exact versions. You can’t install some major 16 nodejs version. But you can still install asdf install <plugin> latest or in case of nodejs lts-* versions.

Don’t forget to pick the version locally or globally.

some side-tip: there is an asdf plugin for direnv!

Adopting Swift Async Await in Vapor

Mon, 15 Nov 2021 00:00:00 +0000

A few months ago Swift 5.5 has been released and made async/await available. And in 4.50.0 Vapor added support for it, too!

If you are still on Vapor 3, you first need to upgrade your server to Vapor 4.

Now we can migrate most usages of Swift NIO’s EventLoopFuture with async. But we don’t have to! This is not a breaking change. I recently performed this upgrade for the server of my app Puffery and as both, the client and the server are open source I will include links to the respective git commits.

Puffery is an app to send messages into channels using Shortcuts or HTTP. This will trigger a push notification to all clients that have subscribed. Within the app you can view your messages and channels.

I wouldn’t recommend to directly replace all occurrences of EventLoopFuture. If you aren’t going to touch specific code paths in a while, there is no need to migrate those. But we’ll come back to that later.

Upgrading to Swift 5.5

If you haven’t already, you need to upgrade your Swift Tools Version within your Package.swift-manifest:

// swift-tools-version:5.5
import PackageDescription

Now a few lines later we need to upgrade to a newer macOS version, because async/await not only requires Swift 5.5, but also macOS 12 Monterey. Make sure you have upgraded accordingly. Otherwise you’d need to work on a linux machine or within a docker container.

let package = Package(
 name: "PufferyServer",
 platforms: [
 .macOS(.v12), // upgrade to .v12
 ],

Next up, we need to bump our dependencies. As we want to rely on special features of the new Vapor, we explicitly go from: "4.50.0". Repeat this with other dependencies like Fluent.

		// ...
 dependencies: [
	 // ...
	 .package(url: "https://github.com/vapor/vapor.git", from: "4.50.0"), // upgrade to 4.50.0
	 // ...
		],

Now, to silence a warning, we need to explicitly declare our Run target as executableTarget.

 targets: [
	 // ...
	 .executableTarget(name: "Run", dependencies: ["App"]),
	 // ...
		]
)

If you use a Dockerfile, build FROM swift:5.5 as build. Also if present don’t forget to update your .swift-version-file and your CI.

Now update your packages using swift package update. If you use Xcode, also update your dependencies using File > Packages > Update to Latest Package Versions to keep them in sync. In theory swift build and swift test should run without any errors. If it does, fix those and proceed.

git commit -am "Upgraded PufferyServer to Swift 5.5"

Adopting Async Await

Now that we upgraded our new Swift version and updated our dependencies, let’s get started with our migration.

We will incrementally do tiny steps and migrate every function after another. But it doesn’t make sense to migrate all functions immediately. If you haven’t touched specific files in a while, there is no need to do so now. A great example are your database migrations. You won’t touch them anyways. Just write new ones with async/await and you are fine.

In my opinion, controllers are the easiest place to get started. Later you can tackle migrate Jobs or ScheduledJobs. Then your services and your repositories.

The easiest places to upgrade will most likely be your Fluent queries: there are overloads for .find() and .all() to return EventLoopFuture and async throws.

Migrate the function signature

- 	func messagesForAllChannels(_ req: Request) throws -> EventLoopFuture<[MessageResponse]> {
+ 	func messagesForAllChannels(_ req: Request) async throws -> [MessageResponse] {

Now fix all issues within the function. Then fix the errors of all callers.

If you temporarily converted invocations of this method from EventLoopFuture to an async function using .get(), it is now time to remove it.

Migrate Protocol Methods if directly affected

Most protocols need to be prefixed with Async like AsyncJob or AsyncScheduledJob. Then you can replace all function signatures.

I need async, but I have an EventLoopFuture

To convert a not yet converted EventLoopFuture, we call EventLoopFuture<V>.get() async throws -> V. You can migrate the function later.

try await theEventLoopFuture.get()

I need an EventLoopFuture, but I have an async function

Sometimes I decided to keep some function signatures as they were and I did not migrate them. For those cases I created a small helper function to create an EventLoopFuture from an async task.

extension EventLoop {
 func from<T>(task: @escaping () async throws -> T) -> EventLoopFuture<T> {
 let promise = makePromise(of: T.self)
 promise.completeWithTask { try await task() }
 return promise.futureResult
 }
}

For example executing multiple futures in parallel is easy with eventLoop.flatten, but it’s much harder with async/await.

Migrate `.flatMap`

Migrate .flatMap({ messages in doSomething(messages) }) to let result = try await doSomething(messages).get().

Migrate `.flatMapThrowing`

Migrate .flatMapThrowing({ messages in doSomething(messages) }) to let result = try doSomething(messages)

Migrate `eventLoop.flatten`

Executing multiple futures in parallel is easy with eventLoop.flatten, but it’s much harder with async/await.

I’d recommend to keep this part as is, and to keep this part as EventLoopFuture. See [I need an EventLoopFuture, but I have async](#I need an EventLoopFuture, but I have async).

Migrate `.transform(to:)`

This is straight forward: use the value directly. Typically you’d return this.

Sometimes I used transform within a flatMap to keep the same return value. Now, just try await these side effects.

-	.flatMap({ user in
-		user.update(on: req.db)
-			.transform(to: user)
-	})
+	try await update(on: req.db)

Migrate `.always(_:)`

.always will be executed when an EventLoopFuture fails and when it succeeds. This is the same behaviour of defer with async/await!

-	return computeSomething()
- .always { _ in
- 	doSomething()
- }
+ defer {
+		doSomething()
+ }
+	return try await computeSomething()

Attention: you probably need to move your defer up. Using async/await will likely introduce more return and throw statements which will exit your functions early.

Returning constant futures

If you currently throw a failing future, just throw the error directly.

- return req.eventLoop.future(error: Abort(.notFound))
+ throw Abort(.notFound)

To replace a succeeding future, return the value directly.

- return req.eventLoop.future(success: value)
+ return value

If thee future(error:) was embedded within a do-catch to lift errors to an EventLoopFuture, you can probably remove the do-catch and mark the function as throws instead.

Test and Commit

Do not forget to regularly run your tests and to keep your project in a green state. From time to time, do some commits.

git commit -am "Use async/await for Vapor"

Real World Examples

In case you need guidance, here are typical examples for Vapor-endpoints. These examples should look familiar.

All code snippets are actual code from Puffery.

Example for a Fluent query

This function is part of the SubscriptionRepository. It is meant to be used from Controllers to consistently access, filter and sort the channel subscriptions of a user.

func all(of user: User) -> EventLoopFuture<[Subscription]> {
	do {
		return try Subscription.query(on: db)
			.filter(\Subscription.$user.$id == user.requireID())
			.sort(\.$createdAt, .descending)
			.all()
	} catch {
		return eventLoop.future(error: error)
	}
}

We start by changing the type signature to async throws.

To fix the type errors, we could drop do-catch as the new variant is throwing. Previously it wasn’t throwing as there is no overload of EventLoopFuture.flatMap that accepts throwing EventLoopFutures. Therefore all(of:) was required to lift thrown errors to futures.

As there is no distinction between directly throwing and a query failure with async/await we can get rid of the do-catch. And as Fluent has overloads for both EventLoopFuture and async throws we’re done here.

func all(of user: User) async throws -> [Subscription] {
	try await Subscription.query(on: db)
	 .filter(\Subscription.$user.$id == user.requireID())
 .sort(\.$createdAt, .descending)
 .all()
 }

Example Migrations for simple read-only endpoints

My MessageController looked like this:

final class MessageController {
	func messagesForAllChannels(_ req: Request) throws -> EventLoopFuture<[MessageResponse]> {
		let user = try req.auth.require(User.self)

		return req.subscriptions.all(of: user)
	 .flatMap(req.messages.latestSubscribed(for:))
 .flatMapThrowing { messages in
	 try messages.map {
	 try MessageResponse($0.message, subscription: $0.subscription)
				}
 }
	}

	// other endpoints ...
}

This code should be familiar to any Vapor developer. I started migration with the function signature, replaced flatMap and flatMapThrowing and inserted the .get().

func messagesForAllChannels(_ req: Request) async throws -> [MessageResponse] {
	let user = try req.auth.require(User.self)

 let subs = try await req.subscriptions.all(of: user).get()
 let messages = try await req.messages.latestSubscribed(for: subs).get()
 return try messages.map {
	 try MessageResponse($0.message, subscription: $0.subscription)
	}
}

After I migrated my SubscriptionRepository, I could even get rid of the trailing .get().

Example Migration for simple write-endpoints

This function’s migration path was more complex.

func confirmEmailIfNeeded(_ user: User) throws -> EventLoopFuture<Void> {
	guard let emailAddress = user.email else {
		return req.eventLoop.future()
	}

	let confirmation = try Confirmation(scope: "email", snapshot: emailAddress, user: user)
	return confirmation.create(on: req.db)
		.flatMapThrowing { _ in
			try Email(/*...*/)
		}
		.flatMap { email in
			self.req.queue.dispatch(SendEmailJob.self, email)
		}
}

Here we could completely remove the empty req.eventLoop.future(). A simple, blank return statement is enough. And creating models doesn’t force us anymore to nest everything one level deeper. We await the result, but we discard it.

func confirmEmailIfNeeded(_ user: User) async throws {
	guard let emailAddress = user.email else {
		return
	}

	let confirmation = try Confirmation(scope: "email", snapshot: emailAddress, user: user)
	try await confirmation.create(on: req.db)
	let email = try Email(/*...*/)
	try await req.queue.dispatch(SendEmailJob.self, email)
}

Summary

Within this post we upgraded our Swift version, Package manifest, docker / CI Swift versions and our dependencies. Then we incrementally migrated portions of our codebase by following a set of rules. What was your migration like? Did you experience any problems?

If you wish, check out the open source repository of Puffery or check it out on the App Store. If you have any questions or feedback don’t hesitate to ask me on @mastodon.social@vknabel or join the Puffery disussions.

Having two admin dev accounts is a bad idea

Mon, 15 Nov 2021 00:00:00 +0000

I tried to keep my work stuff separate from my personal stuff on the same machine. I created two admin users, set up a group for homebrew and set the permissions accordingly.

Sadly this didn’t work out in the long run. So I started to run Homebrew as my preferred admin user.

if [ "$(whoami)" != "vknabel" ]; then
 sudo -S --login -u vknabel bash -- $(which brew) "$@"
else
 brew "$@"
fi

This approach worked and was muich more reliable than the previous approach.

Then came Flutter. I had to add additional permissions and eventually change their ownership from time to time as flutter messed them up.

Converting simple iOS apps to tvOS is easy!

Mon, 02 Aug 2021 00:00:00 +0000

Converting a simple and small iOS app was far easier than expected. Of course webviews, gesture recognizers, navbars, etc. are not supported or work differently, but at a first glance there are not a lot parts with visual regressions!

UIApplication.shared not in Extensions

Mon, 02 Aug 2021 00:00:00 +0000

UIApplication.shared isn’t available within an iOS app extension. To annotate your code paths not needed in an extension, but using UIApplication.shared, just use the @available(iOSApplicationExtension, unavailable) annotation.

Now you will receive the same error when using the annotated api from an extension!

Nestjs has great swagger decorators!

Fri, 16 Jul 2021 11:01:55 +0000

Nestjs has very great decorators to annotate your routes, dtos and controllers. This makes it really easy to keep your Swagger or OpenAPI documentation up to date.

https://docs.nestjs.com/openapi/types-and-parameters

Only downside: as TypeScript interfaces do not exist at runtime, you need to declare all your data transfer objects as classes, which might lead you to add convenience or validation methods to them. Don’t do it. These classes are just decorations.

XPath is powerful

Tue, 13 Jul 2021 00:00:00 +0000

XPath is a really powerful tool to query XML documents, if you are forced to. But in contrast to JSON queries, XPath does not return the actual values, but the nodes or attribtes you queried.

XPath ist ziemlich mächtig und man kommt relativ flott an das gewünschte Ziel. Anders als bei JSON queries erhält man aber nicht die eigentlichen Werte, sonder den Node oder das Attribut selber.

Static Table enums

Mon, 12 Jul 2021 00:00:00 +0000

Using enums in Swift for static Table View Data Sources is really great. Especially when declaring them as enum X: Int and using the rawValue to reflect the section or row index.

You can even use the CaseIterable protocol to count the number of sections or rows.

Reminder: base64 is not secure!

Fri, 02 Jul 2021 16:17:27 +0000

I have never actually seen serious code that’s running in production, that uses base64 encoding for password for over a decade. Today I did.

Here is the not so friendly reminder:

base64 is no encryption or hashing algorithm. You should not use it to encode passwords. And you should’t send the password over HTTP and Basic auth (no HTTPS, not even Digest auth). Even if you do, trade the password for a token. Don’t repeat your mistakes with every single request. And do not store the password locally. Store an encrypted session key instead.

If you don’t follow these basics, delete your code and shut down all your services.

SwiftGen has evolved!

Wed, 30 Jun 2021 00:00:00 +0000

I haven’t used SwiftGen for a long time, but wow, it has improved a lot. I am a bit impressed.

iOS apps require account deletion

Tue, 08 Jun 2021 00:00:00 +0000

Since WWDC21 all iOS apps that provide registration are also required to provide the deletion of those accounts.

Invalid Gradle Private Key

Mon, 07 Jun 2021 00:00:00 +0000

Gradle did reject my ssh key due to invalid privatekey.

The solution: converting it into a different format.

ssh-keygen-p -f id_rsa -m pem

CSS Rotate und Skew

Wed, 02 Jun 2021 00:00:00 +0000

With CSS skew you can simulate a perspective effect. If you want to additionally rotate the element, use rotate first then skew.

Otherwise you might get a really wierd result.

Swift and Firebase

Wed, 02 Jun 2021 00:00:00 +0000

Nothing especially new here, but a reminder: Firebase might be a good choice if you need realtime updates.

Instead of implementing and connecting to websockets and implementing one-time requests and observing differently, you can simply use getData or observeValue as they are already implemented.

Even some errors vanish when observing: you start by the cache and if there is no update due to errors, you don’t get new data. But beware: Firebase still might not be the best choice, depending on your app or the circumstances.

SwiftUI @main AppDelegate

Thu, 27 May 2021 11:56:02 +0000

When using @main on a SwiftUI.App and @UIApplicationDelegateAdaptor(AppDelegate.self) you can still have an AppDelegate without handling SwiftUI manually as without @main.

You don’t even need a SceneDelegate! A huge difference for tiny apps!

Android Permission now requires a description

Thu, 27 May 2021 00:00:00 +0000

Now, Android apps require a description for each permission. Back then, it was optional.

In contrast to iOS, this is only a guideline and not enforced by the Android SDK. Instead the developer needs to implement their own alert. But with great power, comes great responsibility as it could be abused.

Updating Bitrise binary uploads

Thu, 20 May 2021 00:00:00 +0000

Bitrise binary uploads cannot be updated after saving. Instead they need to be deleted and recreated. Thus all workflow steps need to be updated if they rely on the data.

Pro-tip: when copy-pasting, skip the BITRISE_IO and _URL parts – they will be inserted automatically when using the web UI.

Localization order

Tue, 18 May 2021 00:00:00 +0000

When maintaining multiple locales within your project, try to keep line numbers consistent across all locales. Also keep the order of translations consistent.

That makes differences easy to spot.

SwiftUI translations and UIKit

Tue, 18 May 2021 00:00:00 +0000

Nothing new today, but a quick reminder:

Even if you don’t need to explicitly localize String literals for Text manually, you can still need to when passing Strings to UIAlertController or other UIKit classes.

Of course. But sometimes I still forget while writing the code.

ftp-simple vscode workspace

Wed, 12 May 2021 00:00:00 +0000

ftp-simple allows opening FTP connections as VS Code workspace!

Localizcable vs Swift unicode escapes

Wed, 12 May 2021 00:00:00 +0000

Localizable.strings doesn’t support unicode \unnnn escapes, but only \Unnnn! In Swift the \U is for UTF-16 escapes like \Unnnnnnnn.

Android XML Translations

Tue, 11 May 2021 00:00:00 +0000

The Android Studio tooling for Android apps checks and validates all translation keys. Even if they are present within the base language. This comes in handy after greater refactorings.

But sadly the XML does not support XML escapes as '.

NSDataDetector

Tue, 11 May 2021 00:00:00 +0000

How to detect a URL in a String using NSDataDetector - free Swift 5.1 example code and tips https://www.hackingwithswift.com/example-code/strings/how-to-detect-a-url-in-a-string-using-nsdatadetector

Coordinator [unowned self]