2025-09-15 08:00:00
Yesterday was one of those days where a family member had an issue with their computer. "It doesn't open when I click it" was all the information I had going into it. Debugging that through the telephone is just not happening.
I always stayed away from TeamViewer, because I was never really sure if that had a free plan, and the possibility of finding out mid-session that they don't have one was reason enough to save the hassle of yelling the installation instructions through the phone.
I remember hearing about RustDesk in a podcast a couple of years ago. The host claimed it to be a hassle-free open source replacement for TeamViewer, but by the time the next IT-support session arrived, I already forgot about it. Until yesterday!
Yesterday, I just didn't get enough information to be useful. I just needed a way to remotely access the computer, and that's then I remembered the promise of RustDesk. Going in blind, I quickly installed the client on my laptop and sent a mail with the instructions to my family member:
These instructions are fool-proof! And sure enough, they worked. I logged in and debugged the issue. No paywall, no corporate bullsh**, just a simple client that just works as intended out of the box. I was delighted to see that the plan has worked out. Going forward, Rustdesk will be my primary choice for remote IT support.
If you're interested: for some reason the browser window on their screen was resized to a tiny box near the edge of the screen, so whenever they clicked a bookmarked link on their desktop, instead of "nothing happening", they just didn't see the page opening in the browser.
Use RustDesk instead of TeamViewer for a free and easy way to access your family's computer remotely.
2025-06-11 08:00:00
I just learned a cool trick that I want to share. Let's review the diff of a file using git diff. I redacted most of it, but you probably found yourself in the situation of extremely long changes before:
`
diff --git a/lib/ui/screens/detail/components/body/eventbody.dart b/lib/ui/screens/detail/components/body/eventbody.dart
index d19d70a..1a61380 100644
--- a/lib/ui/screens/detail/components/body/eventbody.dart
+++ b/lib/ui/screens/detail/components/body/eventbody.dart
@@ -3,6 +3,7 @@
class EventBody extends StatelessWidget {
final EventDetails details;
@@ -18,35 +19,43 @@ class EventBody extends StatelessWidget {
@override
Widget build(BuildContext context) => Column(
- crossAxisAlignment: CrossAxisAlignment.stretch,
- children: [
- EventInfoView(
- location: details.location,
- start: details.start,
- end: details.end,
- certified: details.certified,
- paid: details.paid,
- points: null, // Already shown in app bar
+ crossAxisAlignment: CrossAxisAlignment.stretch,
+ children: [
+ EventInfoView(
+ location: details.location,
+ start: details.start,
+ end: details.end,
+ certified: details.certified,
+ paid: details.paid,
+ points: null, // Already shown in app bar
+ ),
+ const SizedBox(height: 24),
+ Html(
+ data: details.description,
+ style: {
+ 'body': Style(
+ margin: Margins.zero,
...
}
`
But do you spot what has ACTUALLY been changed? In a real world scenario, it probably took you a while before you realised that it's the result of formatting the entire file. Nobody cares about whitespace when reviewing code. Or rather, your brain should not take the burden of having to care about that. That's what linters are for!
Let's look at the same diff with the --ignore-all-space (shorthand -w) flag activated:
diff --git a/lib/ui/screens/detail/components/body/event_body.dart b/lib/ui/screens/detail/components/body/event_body.dart
index d19d70a..1a61380 100644
--- a/lib/ui/screens/detail/components/body/event_body.dart
+++ b/lib/ui/screens/detail/components/body/event_body.dart
@@ -3,6 +3,7 @@
class EventBody extends StatelessWidget {
final EventDetails details;
@@ -29,6 +30,14 @@ class EventBody extends StatelessWidget {
points: null, // Already shown in app bar
),
const SizedBox(height: 24),
+ Html(
+ data: details.description,
+ style: {
+ 'body': Style(
+ margin: Margins.zero,
+ ),
+ },
+ ),
Text(details.description, style: context.theme.textTheme.body2Regular),
if (details.registrationUrl != null || details.programUrl != null) const SizedBox(height: 16),
if (details.registrationUrl != null) ...[
Huh, so it's NOT just a formatted file. All whitespace changes have been stripped out, and you only see the changes that are relevant for the review. Neat!
Many tools also support ignoring whitespace. GitLab let's you disable Show whitespace changes in the merge request diff viewer. VSCode has the diffEditor.ignoreTrimWhitespace setting. So, if you want to make this the default in your tools, chances are there's an option for only showing relevant changes.
A bit of a sloppy post, but I hope this is useful to someone. Happy code reviewing!
2025-05-20 08:00:00
This applies to work tasks just as much as it applies to hobbies. No matter what you do, always create some sort of breadcrumb that you or someone else can pick up down the line.
If you build a feature into your app, you've generated an output, and therefore value. But what if you bang your head against the wall and don't make any progress? Write about it. Write about your challenges, document what you've learned and share it with your peers. Not reaching a set goal doesn't mean failure. It's an opportunity to create value in a way you didn't anticipate.
If you're out on a run and a thought pops into your head, record a memo on your phone, or better yet: keep a tiny notebook with you at all times. Thoughts slip in and out of our heads at a very rapid pace. Capturing thoughts, even if you don't share them with anyone else, is a great way to generate value out of thin air.
If you're into crafty hobbies like woodworking, painting or baking, you likely know how important it is to finish a project. No matter how good or bad the outcome is, every finished project is an artifact that you can look back at later and see the progress you've made.
Output always means value, even if it's not immediately apparent. Just keep on laying down those breadcrumbs.
2025-03-25 08:00:00
There are a couple of interfaces that container orchestration systems (like Kubernetes) implement to expose certain behavior to their container workloads. I will only be talking about Kubernetes in this post since it's the orchestrator I'm most comfortable with, but some interfaces are also implemented in other orchestrators (like HashiCorp Nomad) too, which makes the interfaces cross-platform.
Storage behavior used to be built into Kubernetes. The container storage interface (CSI) defines a unified interface to manage storage volumes, regardless of the orchestrator (as long as they implement the CSI). This makes it way easier for third-party storage providers to expose data to Kubernetes. If a storage provider implements this interface, orchestrators can use it to provision volumes to containers. Notable storage providers are:
A full list of CSI drivers can be found here.
The Container Runtime Interface (CRI) is an API that allows Kubernetes to use different container runtimes without needing to recompile the entire Kubernetes codebase. Before CRI, Kubernetes had a direct integration with Docker, making it difficult to use alternative container runtimes.
CRI defines the API between Kubernetes components (specifically kubelet) and container runtimes. This abstraction allows Kubernetes to support multiple container runtimes simultaneously, giving users the flexibility to choose the runtime that best fits their needs. Some popular container runtimes that implement the CRI include:
With CRI, switching between different runtimes becomes more straightforward, allowing operators to optimize for security, performance, or compatibility based on their specific requirements.
The Container Network Interface (CNI) defines a standard for configuring network interfaces for Linux containers. Similar to CSI and CRI, the CNI was created to decouple Kubernetes from specific networking implementations, allowing for a pluggable architecture.
CNI plugins are responsible for allocating IP addresses to pods and ensuring proper network connectivity between pods, nodes, and external networks. They implement features like network policies, load balancing, and network security. Some popular CNI plugins include:
Each CNI plugin has its strengths and is suitable for different use cases. For example, Calico excels at enforcing network policies, Cilium is optimized for performance and observability, while Flannel is valued for its simplicity.
One thing I've always admired about Kubernetes is its pluggable architecture. These standardized interfaces (CSI, CRI, and CNI) showcase how well-designed the system really is. Instead of building everything into the core, the Kubernetes team made the smart decision to create extension points that allow the community to innovate without touching the core codebase.
The great news? You don't have to swap out all these components or even understand them deeply to use Kubernetes effectively. While the array of options might seem daunting at first glance, most Kubernetes distributions (like EKS, GKE, AKS, or Rancher) come with sane defaults that work well out of the box. They've already made sensible choices about which storage, runtime, and networking components to include.
This pluggability is what makes Kubernetes so powerful for those who need it. Need a specific storage solution? Plug in a CSI driver. Want a more secure container runtime? Swap in a different CRI implementation. But for everyone else, the defaults will serve you just fine.
The beauty of this approach is that it gives you room to grow. Start with the defaults, and when you have specific requirements, the extension points are there waiting for you. That's the real magic of Kubernetes – it works great out of the box but doesn't limit your options as your needs evolve.
2025-02-27 08:00:00
So far, whenever I wanted to recycle a prompt from another context in Claude (though this also applies to ChatGPT and some other LLMs), I went back in my conversation history, copied the prompt, pasted it in a new chat and adjusted the context. But I recently discovered that Claude Projects can be misused as "prompt templates", which makes it way easier to handle repetitive tasks.
In Projects, you can set a system prompt that will be applied to all conversations in the project. I guess it's supposed to be used for relevant information about whatever you want to work on, but I like to think about a project more as a prompt template, rather than a project. For example, here's a project prompt that I use to brainstorm project ideas:
Ask me one question at a time so we can develop a thorough, step-by-step spec for this idea. Each question should build on my previous answers, and our end goal is to have a detailed specification I can hand off to a developer. Let’s do this iteratively and dig into every relevant detail. Remember, only one question at a time.
(Stolen from this great blog post)
While you could copy and paste this from a text file into every new conversation, Claude's projects make it super easy to save this as a template.
I guess this is an obvious feature for some people, but to me, it was a huge help once I found this out.
Got any other neat tricks for working with LLMs? I'd love to hear them!
2024-12-29 08:00:00
It's super exciting looking back at 2024. So much has happened! I haven't been very active on this blog lately, mainly because I've been super busy in other areas of life.
The biggest change for me this year is one that I can cross off of my impossible list: We bought a house! I've been wanting to write post about this for a few weeks, and now that things are settling in, I might have the time to do that. In short: We moved from Brunswick (Germany) back to a more rural town just outside Brunswick. It's closer to my girlfriends workplace, closer to my family and overall way cheaper than properties in Brunswick. We're super happy about the house and have yet to find any major annoyances. The neighbors are nice, and the community is incredibly wholesome.
As for other personal projects, there hasn’t been as much traction as there used to be. My interests have partially shifted to hobbies that don’t involve a computer, which I’m grateful for. I still love building software projects – especially now that it’s become so easy to get started with a project using an AI brainstorming companion – I just do it less often. I picked up running as a hobby (more on that later), gather with friends to play Dungeons & Dragons and work on stuff in my new basement.
These are the goals I set myself for 2024:
Build a side project that generated at least 100€ of value
That’s a bust. As mentioned, I haven’t really spent a lot of time building side projects. And the ones I did build, I consider tools rather than an income stream.
Get a scuba diving license
I’m a certified PADI Open Water Diver! You can see some impressions here and here.
Do a 10 km run (I really need to start moving again)
I ran three 10k runs this year. The first in May, then in June and finally, in September, I improved my 2018 personal best by a few minutes!
Sell my car
Check. More infos here.
Write at least 50 blog posts
I didn’t reach this goal, but I’m also not disappointed by it. The frequency of my posts varies, and this year it was just lower than before.
Here are some new goals for this year:
The results for last years predictions:
Bitcoin will at last reach a value of 100,000$, following the halving likely happening in 2024
Bitcoin did reach 100,000$, though not following the halving event. Still, I’d call this a pass!
SpaceX will use a Starship prototype to launch Starlink satellites into orbit
Nope, they didn’t. But they made incredible leaps.
Tesla cars a still not fully self driving (reference)
They claim to launch it in Europe earlier next year. It’s currently in closed testing. Still, I wouldn’t give it a pass.
Google will replace their main search with an AI chat bot (see Bard)
Not sure if I’d call Gemini a full replacement, but it does have a wrapper around their traditional search engine. The product is shit compared to Anthropic and OpenAI, but I would call this a pass, since you can use Gemini instead of Google Search.
And that's a wrap. I hope you all had a wonderful Christmas (if celebrated), and are as excited as I am for the new year!
