Engineering on Markus Löning

Agentic engineering and skills

Fri, 05 Jun 2026 14:23:23 +0100

AI agents like Claude Code or Codex are non-deterministic tools, which can be modified, tweaked and used in many different ways. Using them effectively requires mastering them and making them your own to some degree, even when agents and the LLMs they rely on are still evolving.

Simulating application runs

Thu, 26 Mar 2026 20:59:00 +0100

Dry runs

Before running a program for real, we sometimes first want to simulate the outcome, a dry run without actually changing anything, to better understand the consequences of running the application. This is particularly useful when the program involves state changes that are difficult to revert. For example, writing to a database, deleting files, or provisioning cloud resources.

Working with Claude Code

Sat, 07 Mar 2026 14:58:15 +0100

Notes and links about Claude Code and agentic engineering.

How Claude Code work

It’s not hard to understand the basic workings of coding agents like Claude Code:

EuroRust 2025

Sat, 11 Oct 2025 11:58:15 +0200

I attended my first Rust conference, EuroRust 2025 in Paris.

clippy settings recommendations, including pedantic or undocumented_unsafe_blocks (structured safety documentation) for unsafe code
best practices for Rust development by jhpratt (slides, also see his related talk on compiler-driven development)
inner workings of the Rust compiler, compiler settings and their trade-offs including inlining, monomorphization link-time optimizations (LTO) by noratrieb (slides, Rust performance book)
best practices for error handling: for anticipated errors, prefer thiserror for libraries to expose concrete and structured errors, and Result type and anyhow for application code, for unanticipated errors use panic! (programmer mistake)
criterion and flamegraphs for profiling
inner working of atomic types for concurrency and memory ordering
prefer concrete types (e.g. enums) over generics and traits, for speed due to monomorphization and readability, especially in application code
presenterm for making presentations in your terminal
embassy for embedded systems
bevy game engine
the concept of run-time reflection and and Rust’s compile-time solutions based on procedural macros like serde’s derive, e.g. when you add #[derive(Serialize, Deserialize)] to a struct, you are using a procedural macro that runs when you compile your code; the macro inspects the definition of your struct (e.g., the field names and types), and based on this inspection automatically generates the implementation of the core Serialize and Deserialize traits for your specific type
triemap, a tree-based data structures primarily used for efficient storage and retrieval of associative data where the keys are strings or sequences, e.g. for fast prefix-based lookup
foreign function interfaces (FFI) in Rust for using functions from other programming languages, particularly C (e.g. using extern)
Valgrind for profiling and memory debugging
data engineering
- OLAP (analytical)
  - batch operations involving complex queries, aggregations and scans across many rows but few columns
  - primarily columnar data format, e.g. Parquet/Arrow
  - data warehouse solutions like Delta Lake and Snowflake
- OLTP (operational)
  - frequent inserts, updates, deletes, and fetching full records (e.g. banking transactions, user profiles)
  - row-based format (e.g. PostgreSQL)
  - document-based/NoSQL databases (e.g. MongoDB), better for complex entities to avoid complicated SQL joins

Videos will be available at: https://www.youtube.com/@eurorust.

Network engineering

Thu, 24 Jul 2025 23:07:58 +0200

Intro

I recently had to think more about network engineering. Here are my notes from reading Beej’s Guide to Network Programming and Computer Networking: A Top-Down Approach.

How to name things

Thu, 16 Jan 2025 18:07:07 +0100

In software engineering (and machine learning), we often need to name things to refer to them more easily in our discussions – be it projects, products or servers.

Signing git commits

Tue, 14 Jan 2025 20:50:10 +0100

https://withblue.ink/2020/05/17/how-and-why-to-sign-git-commits.html

If a key expires, you can update the expiration date as follows:

gpg --list-secret-keys to list the secret keys and look up the key ID, alternatively gpg --list-keys
gpg --edit-key <key-id> to open the gpg console
run expire in the gpg console and follow the prompts to update the expiration date
finally save and quit

You can type help in the console for other available commands.

Logging in a multiprocessing context in Python

Mon, 02 Dec 2024 09:38:37 +0100

Configuring loggers in a Python application with multiprocessing isn’t straightforward.

If you’re new to logging in Python, there’s a basic tutorial.

Implementing the Uno card game in Rust

Sat, 09 Mar 2024 00:06:13 +0100

After having implemented the Uno card game in Python, I decided to rewrite it in Rust.

Rewriting Uno in Rust has taught me a lot, as Rust forces you define objects and their interactions more clearly, and encourages you to keep them as simple as possible.

Implementing the Uno card game in Python

Wed, 20 Dec 2023 19:16:09 +0100

A friend of mine recently implemented the card game Uno as a programming exercise in Python and asked me for feedback. I thought it’s a good idea to try it myself and then compare notes.

Run pre-commit retrospectively on all changed files in a PR

Fri, 02 Oct 2020 16:10:57 +0200

When I was developing sktime, we had set up automated checks for printing and formatting only after some time. Rather than fixing our entire code base in one go, we decided to roll out the changes slowly, and only enforce them for the changed files on a PR.