Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is haselkern?
haselkern is the personal website of Lars, a software developer from northern Germany. It is a small, hand-built home on the web rather than a product or service: a short introduction to the author, a collection of his own blog posts and notes, a reading list of technical blogs he follows, and a set of articles he recommends.
What you will find there
- A personal introduction: Lars describes his interests in technology, programming, music, art, game development and plants, and traces his computing background from Windows to Linux distributions such as Manjaro and Pop, and currently a MacBook.
- Technical preferences: He names Rust as his favorite programming language, followed closely by Go, and lists Java, TypeScript, JavaScript, C# and Python as others he has used.
- Blog recommendations: A curated list of technical blogs, including fasterthanli.me for detailed Rust and programming explanations, Julia Evans for illustrated technical concepts, and Red Blob Games for interactive game-development articles.
- Recommended reading: Articles he returns to for reference or shares with colleagues, on topics such as semantic line breaks, writing good Git commit messages, parsing instead of validating, and keeping a changelog.
- Site notes: The site is built with Hugo using a custom theme derived from the Zola ʕ•ᴥ•ʔ Bear Blog theme, and its history goes back to 2016.
Who it is for
It suits developers who enjoy reading personal blogs and want pointers to well-regarded technical writing, especially around Rust, Go, functional programming and game development. If you are looking for tutorials, documentation or a commercial service, this is not that kind of site; it is one person's notes and links.
A useful next step is to start with the "Recommended" section if you want practical engineering reading, or the blog list if you are choosing which technical writers to follow.
Who is Lars, the software developer behind haselkern?
Lars describes himself on haselkern as a software developer from northern Germany. His intro is brief and personal: he is fascinated by technology and names programming, music, art, game development and plants among his interests.
What the site reveals about him
- Tools and platforms: He says his computer history began on Windows, later moved to Linux (Manjaro and Pop), and that he currently uses a MacBook.
- Languages: He calls Rust his favorite programming language, closely followed by Go, and lists Java, TypeScript, JavaScript, C# and Python as others he has used.
- How he writes: The site is built with Hugo using a custom theme derived from the Zola "Bear Blog" theme, which he praises for its simplicity. He also links to a record of how the site has changed since 2016.
- What he reads: He shares a set of technical blogs he follows, including fasterthanli.me on Rust and programming concepts, jvns.ca on technical explanations, Red Blob Games on game development visualizations, and samwho.dev on algorithms.
- Reference material: He keeps a short "Recommended" list of articles he returns to, such as "Semantic Line Breaks," "How to Write a Git Commit Message," "Parse, don't validate" and "Keep a Changelog."
If you want to judge whether his writing matches your interests, start with that Recommended list: it shows the conventions and explanations he values, which is a fair preview of the kind of technical content he is likely to appreciate and produce.
Which programming languages and tools does Lars prefer and why?
Lars names Rust as his favorite programming language, closely followed by Go. He has also worked in Java, TypeScript, JavaScript, C# and Python, but the page presents those as languages he has used rather than ones he prefers. His stated reason for favoring Rust and Go isn't spelled out beyond that ranking; what he does explain is a broader preference for simplicity, which shows in his choice of a Hugo-built site with a custom theme derived from the Zola ʕ•ᴥ•ʔ Bear Blog theme — "I love the simplicity of it!"
His tool history is a useful signal about how he works: he started on Windows, moved to Linux (Manjaro, Pop), and now uses a MacBook. That reads as someone who tries environments rather than settling on one out of habit, and it fits a developer who writes systems-oriented code (Rust, Go) but keeps a mixed toolbox for other work.
What the preferences imply in practice
- Rust first: a good match if you care about correctness and explicit control, and are willing to accept a slower compile-and-iterate loop while learning.
- Go second: the pragmatic pick for services and tooling where fast builds and a small language surface matter more than expressiveness.
- The rest as context: Java, TypeScript, JavaScript, C# and Python suggest he can move across backend, web and scripting work rather than being tied to one ecosystem.
Concrete scenario
Suppose you're choosing a language for a small command-line tool you'll maintain alone for years. Lars's ranking points toward Rust if you want the compiler to catch mistakes early and don't mind the upfront effort; Go if you'd rather ship quickly and keep the code easy to hand off. If the tool must plug into an existing web or enterprise codebase, his broader language list is the more relevant part of the page — pick for the surrounding stack, not the favorite.
As a next step, skim the blogs he recommends for depth on these choices: fasterthanli.me for detailed Rust and programming explanations, and jvns.ca for concepts explained with text and infographics. His own notes on writing and editing — semantic line breaks, commit messages, "parse, don't validate" — are worth reading if you want to see the habits behind the tool choices.
Which blogs does Lars recommend for learning about Rust and programming concepts?
Lars points readers toward fasterthanli.me for Rust and programming concepts, describing it as covering those topics "with a lot of detail and background information." That emphasis on depth makes it the natural pick when you want to understand why something works in Rust rather than just copy a snippet.
For programming concepts more broadly, his list includes:
- fasterthanli.me — Rust and programming concepts, with extensive background
- jvns.ca — technical concepts and programs explained with text and infographics
- lexi-lambda.github.io — functional programming and programming in general
- samwho.dev — explanations and interactive visualizations about algorithms
- two-wrongs.com — stories and thoughts about software development
If your goal is Rust specifically, start with fasterthanli.me; if you are learning algorithms or prefer visual explanations, samwho.dev and jvns.ca suit that style better.
What articles does Lars recommend for writing better code and commit messages?
Lars keeps a short "Recommended" list of articles he returns to for reference or shares with colleagues who ask why he does things a certain way. For writing better code and commit messages, the relevant picks are:
- How to Write a Git Commit Message — a guide to clearer, more consistent commit messages.
- Parse, don't validate — an argument for designing code so invalid states can't be represented, rather than checking inputs after the fact.
- What I think about when I edit — notes on editing prose, useful for writing documentation, READMEs and commit text.
- Semantic Line Breaks — a convention for breaking text at sentence or clause boundaries, which keeps diffs and reviews cleaner.
- keep a changelog — guidance on maintaining a changelog people can actually use.
These are editorial recommendations on haselkern, not tutorials hosted there; the articles themselves live elsewhere, so treat the list as a reading queue rather than documentation. A practical next step: start with "How to Write a Git Commit Message" and apply it to your next five commits, then read "Parse, don't validate" when you next design a function that takes user input. If you want more depth on the reasoning behind such choices, Lars also points readers to blogs like fasterthanli.me for detailed Rust and programming explanations and jvns.ca for approachable technical write-ups.
How has haselkern changed since it was created in 2016?
The page doesn't describe its own history in detail. Lars only notes that the site was built with Hugo on a custom theme derived from the Zola ʕ•ᴥ•ʔ Bear Blog theme and links to a page showing how the site changed since 2016. The visible content tells you what it is now rather than what changed along the way: a personal developer blog with short notes, a tech section, a list of blogs he reads and a small set of recommended articles.
What the current version suggests about its direction
- Simplicity as the goal. The theme choice is described as loved for its simplicity, which points to a stripped-back reading experience rather than a feature-heavy site.
- Breadth over a single niche. The topics span programming, music, art, game development and plants, so it reads as a personal notebook rather than a focused technical publication.
- Curated links as content. The blog and recommended-article lists are part of the site's value, functioning as a reading list for people with similar tastes.
A practical next step
If you want the actual timeline, open the change-history page linked from the homepage and compare early posts with recent ones. Look for shifts in subject matter, post length and how often he writes about Rust versus other languages. For a sense of the wider reading culture he points to, fasterthanli.me covers Rust in depth, and Julia Evans explains technical topics with diagrams.
User reviews (0)