Posts on belief driven design

What synchronized Actually Does

Tue, 12 May 2026 00:00:00 +0000

Asked for a one-line mental model of what synchronized does, most have a simple answer: making sure only one thread at a time can access the synchronized block or method.

The Secret Life of a Java String

Tue, 17 Mar 2026 00:00:00 +0000

String is the most-used type in any Java codebase, without much competition. And yet, most developers don’t know much about what actually happens under the hood.

GC-Free Indexing and Compaction (Part 3)

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

After Part I gave us raw I/O performance and Part II gave us safety and durability, there are still two fundamental flaws currently present:

Reads are slow:
Every lookup requires scanning the entire segment. This means an O(n) operation, and that’s unacceptable.
Disk usage is unbounded:
Updates and deletes leave garbage bytes on the disk behind forever. So eventually, we run out of space.

In this final article, it’s time to tackle both issues.

Designing a Crash-Resilient Binary Format (Part 2)

Wed, 14 Jan 2026 00:00:00 +0000

In the previous article, we built a fast append-only log using Java’s Panama FFM API.

It was clean, efficient, and… fundamentally broken.

Building a Storage Engine in Modern Java with Panama (Part 1)

Mon, 12 Jan 2026 00:00:00 +0000

Java has often been dismissed for latency-sensitive systems programming in the past. Not because it’s slow, but because it’s unpredictable.

UUIDv7 in Java

Mon, 15 Dec 2025 00:00:00 +0000

UUIDs are the dark matter of modern software. You rarely look at them directly, but they hold the distributed universe together. They are the easiest way to create a unique identifier, which is why they quietly power so many systems.

How Fast Are Streams Really?

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

Java Streams have significantly impacted how we process data since their release in 2014. The fluent and declarative API offers undeniable advantages in readability, conciseness, and safety, especially for complex transformations or large datasets.

But what about the bread-and-butter tasks?

Shell Navigation 101

Wed, 26 Feb 2025 00:00:00 +0000

Navigating the shell is an indispensable skill. While GUIs might be more intuitive in some ways than the command line, they lack the speed and raw power a shell offers. Therefore, efficient shell navigation that goes beyond just cd goes a long way.

Taking Out the Trash in Java

Wed, 05 Feb 2025 00:00:00 +0000

Memory management is a critical aspect of any programming language. It ensures that applications efficiently use the available resources without leaking memory or crashing.

Why Everyone Talks About Zig

Tue, 21 Jan 2025 00:00:00 +0000

There’s a new contender in the ever-evolving landscape of programming languages everyone seems to talk about: Zig.

What Happens After We Hit Compile in Java?

Wed, 08 Jan 2025 00:00:00 +0000

When writing Java code, our primary focus is the classes, methods, and best coding practices. However, once we hit “compile,” the source code undergoes quite a transformation before execution.

Templating with Thymeleaf: Custom Dialects and More (Part 3)

Mon, 04 Nov 2024 00:00:00 +0000

In the previous articles, we explored the fundamentals of Thymeleaf and focused on reusability with fragments and the Layout Dialect.

Now, in this final installment, we’ll dive into the more advanced features, like creating a custom dialect, processors, and more.

Templating with Thymeleaf: Fragments and Reusability (Part 2)

Thu, 24 Oct 2024 00:00:00 +0000

It’s time to dive into one on Thymeleaf’s most powerful aspects: layout management and reusability. These concepts are essential for creating maintainable and efficient templates.

Templating with Thymeleaf: The Basics (Part 1)

Wed, 16 Oct 2024 00:00:00 +0000

Thymeleaf is a modern Java template engine for both web and standalone applications. Although widely used in the Spring ecosystem, it can be integrated into any JVM environment. If you need a dynamic, flexible, and extensible templating engine, Thymeleaf might be just what you need.

The Bytecode Chicken-Egg Problem

Mon, 30 Sep 2024 00:00:00 +0000

Bytecode is the (mostly) invisible superpower of the Java Virtual Machine (JVM). Even though it’s an essential part of the Java ecosystem puzzle, it’s also a niche topic and behind-the-scenes feature that many of us do only have surface knowledge of. However, there’s a chicken-egg problem lurking within Bytecode libraries which the OpenJDK team intends to fix with JEP 484.

Using Indexed and Associative Arrays in Bash

Wed, 10 Jul 2024 00:00:00 +0000

Shell scripting is vital for automating repetitive tasks and simplifying complex commands into a more straightforward format. Understanding the details of shell scripting enables us to write more robust, portable, and efficient scripts.

Understanding Java Generics: Key Features and Common Pitfalls

Wed, 26 Jun 2024 00:00:00 +0000

Generics are an indispensable feature in the world of Java programming, shaping how we write and interact with code. Despite their ubiquity and importance, many developers only scratch the surface of what Generics can do.

Reclaim Your Gmail Inbox with Google Scripts

Mon, 10 Jun 2024 00:00:00 +0000

Inbox Zero aims to declutter your mind and remove any anxiety over unread or missed emails lingering in your inbox. Instead of answering each email as soon as it arrives or letting it “rot” in the inbox, a tickler file relegates them until they become a priority and must be reviewed. So, let’s create our own tickler file with the help of Google Apps Scripts.

Exploring Java's Units of Measurement API (JSR 385)

Wed, 29 May 2024 00:00:00 +0000

Dealing with unit conversion is always a pain point. At first, it seems simple enough until you hit the first edge-case. Just like with Date and Time (JSR 310), there’s a well-specified solution available, although not directly in the JDK: the Units of Measurement API (JSR 385).

Looking at Java 22: Multi-File Source-Code Programs

Tue, 21 May 2024 00:00:00 +0000

Software development is a dynamic process, especially in the early stages of a project or when experimenting with new ideas. During these phases, files and overall structures can change frequently. Java, traditionally known for its strict organizational requirements, has made impressive strides to accommodate this fluidity and become more beginner-friendly.

Shell Traps and Posix Signals

Wed, 08 May 2024 00:00:00 +0000

Shell traps catch POSIX signals (and more) to allow asynchronous inter-process communication to inform any process or particular thread of various events and do some work. But do you know about all the different signals and ways to use the trap command?

Looking at Java 22: Stream Gatherers

Mon, 29 Apr 2024 00:00:00 +0000

The Stream API provides a rich and versatile set of intermediate operations, even though certain ops are still missing or are hard to implement with the given ones.

Whereas terminal ops are quite customizable by writing our own Collector, an equivalent wasn’t available until now as a preview: Stream Gatherers.

Looking at Java 22: Foreign Function & Memory API

Wed, 17 Apr 2024 00:00:00 +0000

The Foreign Function & Memory API, part of Project Pananama, improves Java’s interoperability with code and data outside the JVM. Calling native libraries and working with native memory becomes safer and more straightforward than using the fragile and often dangerous JNI.

Looking at Java 22: Class-File API

Tue, 09 Apr 2024 00:00:00 +0000

Class files and the underlying Bytecode serve as the universal language within the Java ecosystem. Parsing, generating, and transforming class files are essential tasks enabling many of the tools and libraries we use daily.

Working with Numbers in Java

Tue, 02 Apr 2024 00:00:00 +0000

There’s more than one way to work with numbers in Java. We have access to 7 numeric primitive types and their boxed counterparts, high-precision object types, multiple concurrency-akin types and helpers, and more.

Looking at Java 22: Unnamed Variables & Patterns

Tue, 19 Mar 2024 00:00:00 +0000

In this article, I want to talk about a non-preview feature belonging to Project Amber, JEP 456.

With Java 9, the _ (underscore) became a reserved keyword and no longer a valid identifier. Now, with the release of Java 22, the new keyword finally gets a specific meaning: something not having a name.

Grabbing Screen Text with a Shell Script

Mon, 18 Mar 2024 00:00:00 +0000

Recently, I stumbled upon an OCR tool for Linux. However, I didn’t like the idea of needing a GUI app, so I wrote a shell script connecting the right CLI tools instead.

This article dissects “grab-text”, a simple POSIX-compatible shell script I wrote for grabbing text from your screen.

Looking at Java 22: Statements before super

Thu, 14 Mar 2024 00:00:00 +0000

The first (preview) feature of Java 22 I want to talk about is one I’m quite excited about!

JEP 447 introduces a significant change by relaxing the strict rules for constructors. It finally allows (certain) statements to be executed before calling the super(...) call.

Looking at Java 22: Intro

Tue, 12 Mar 2024 00:00:00 +0000

Java 22 is just around the corner (GA 2024-03-19), so it’s time to look at (most of the) included goodies, much like we did with the previous version.

This time around, the new version includes 12 JEPs in total, with 7 being previews and a single incubator one.

Better Code Snippets in JavaDoc

Wed, 06 Mar 2024 00:00:00 +0000

Effective documentation is an essential staple of every software project. Still, way too often, we neglect it at the moment. If we’re lucky, our future selves will take care of it. But let’s be honest here for a moment… it won’t happen!

Consequently, any improvement that makes writing documentation more straightforward and easily accessible is an important and welcomed one.

Java Enums 101

Tue, 20 Feb 2024 00:00:00 +0000

Introduced in 2004 alongside Java 5, Enums are a distinct type identified by their own keyword. They encapsulate a predefined, fixed set of named constants. This simple characteristic already provides ample value in our day-to-day code. However, their application extends beyond merely consolidating constants within a single type.

Test Swift Packages with a Test Host

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

Swift packages are a neat and simple way to bundle up and share code. They remove the overall complexity by not requiring an Xcode project but instead relying on a filesystem-based project layout. That’s all fine and well until your code needs an Entitlement for it to be tested.

Looking at Java 21: Structured Concurrency

Tue, 24 Oct 2023 00:00:00 +0000

Project Loom, with its aim to deliver “easy-to-use, high-throughput, lightweight concurrency”, will most likely change how we approach concurrency in the future. Today, we will look at the “glue” that can hold it all together: Structured Concurrency.

Looking at Java 21: The Little Things

Thu, 12 Oct 2023 00:00:00 +0000

Besides the “big” features that often aggregate under well-known project names, like “Amber”, “Loom”, or “Panama”, there are many little things in every release that are easy to miss. These API and tool improvements might not be as visible as other features, as they’re not represented by a JEP. That doesn’t mean we don’t need to know about them.

Looking at Java 21: Virtual Threads

Thu, 05 Oct 2023 00:00:00 +0000

One of the most significant features of Java 21 is Virtual Threads (JEP 444). These lightweight threads reduce the effort needed for writing, maintaining, and observing high-throughput concurrent applications.

Shell Redirection 101

Mon, 02 Oct 2023 00:00:00 +0000

Shell redirection can be confusing. I’ve always wondered what 2>&1 means and why it’s needed, but as many others, I just copy/pasted things from the internet into my terminal and hoped for the best. What could possibly go wrong?

Revisiting Java for Shell Scripting

Thu, 21 Sep 2023 00:00:00 +0000

Around 6 years ago, I wrote about using Java for shell scripts. It was a hacky and fragile way to convert some Java code into a shebanged file containing the content of a Jar file.

However, Java evolved quite a bit since that article, so it’s time to look at it again.

Xcode String Catalogs 101

Tue, 19 Sep 2023 00:00:00 +0000

Localization, or l10n, is an important step for any app to reach a broader market and be more inclusive. With Xcode 15, the IDE gained a versatile and easy-to-use way of handling localization: String catalogs.

Looking at Java 21: Generational ZGC

Tue, 12 Sep 2023 00:00:00 +0000

A new garbage collector was introduced in Java 11, a low latency/high scalability GC called ZGC. And now, with Java 21, it has evolved into a generational GChugo .

Looking at Java 21: Record Patterns

Tue, 05 Sep 2023 00:00:00 +0000

Pattern matching is a declarative and composable approach for more powerful and expressive code. Java 16 added pattern matching for the instanceof operator, and we looked at pattern matching for switch before. Let’s look at another new kind of pattern matching: Record Patterns.

Looking at Java 21: Feature Deprecations

Mon, 28 Aug 2023 00:00:00 +0000

Even though Java is one of the most backward-compatible languages and environments I’ve ever worked with, there’s always the possibility of feature deprecations and even removals.

Xcode Breakpoints 101

Tue, 22 Aug 2023 00:00:00 +0000

Knowing how to debug a problem is essential in any project. But there’s way more to it than just stopping at a certain point with a breakpoint. From running custom code, over symbolic breakpoints, to sharing breakpoints via Git, Xcode has something for everyone.

Looking at Java 21: Switch Pattern Matching

Tue, 08 Aug 2023 00:00:00 +0000

The switch control structure has quite an evolution lately since its inception. First, there were switch expressions (JEP 325, 354, 361). And now, we get pattern matching for switch statements and expressions!

Looking at Java 21: Scoped Values

Mon, 17 Jul 2023 00:00:00 +0000

Today we look at Scoped Values, another interesting preview feature that’s incubating since Java 20 (JEP 429). It’s a new way to store and share immutable data with a bounded lifetime within a thread and its child threads.

Looking at Java 21: Sequenced Collections

Thu, 29 Jun 2023 00:00:00 +0000

Dealing with Collections is improving with Java 21, as three new interfaces get retro-fitted right into the existing type hierarchies. These Sequenced Collections give us a uniform API to access the first and last elements, and process Collections in reverse.

Looking at Java 21: Simpler Main Methods and Unnamed Classes

Thu, 22 Jun 2023 00:00:00 +0000

Java’s known (and often criticized) for its vast amount of required boilerplate and ceremony for perceived mundane tasks, at least compared to other languages. JEP 445 is explicitly targeted to make the first introduction to Java a breeze, though.

Looking at Java 21: String Templates

Tue, 20 Jun 2023 00:00:00 +0000

Java’s String type is a ubiquitous type that’s used in every program out there. Over the years, it received many improvements. And now, another exciting improvement is coming that makes String safer and easier to use: String templates.

Looking at Java 21: Intro

Fri, 16 Jun 2023 00:00:00 +0000

Java 21 has recently entered “rampdown phase one”, and is planned for general availability in September! This new LTS release comes with many new features, that’s why I want to take the next few weeks to take a deeper look at the ones that excite me the most!

"A Functional Approach to Java" is finally here!

Fri, 19 May 2023 00:00:00 +0000

I’m happy to announce that my book, “A Functional Approach to Java: Augmenting Object-Oriented Java Code with Functional Principles” is finally available 🥳

Traveling with (only) an iPad

Mon, 03 Apr 2023 00:00:00 +0000

After becoming a workaholic in the last three years and spending 7 days almost every week in the office, it was time for a vacation and change of scenery: a 25 days trip to South Korea and Japan. But I still needed to work on my book, so I had to take at least one device capable of doing that with me.

Deploying Hugo with GitHub Actions

Wed, 01 Mar 2023 00:00:00 +0000

Almost 3½ years ago, I moved this blog from GitHub pages to my own little machine in the ether. The deployment process was based on Docker and a single Git hook. To simplify my setup further, I revamped it to use GitHub Actions instead.

Functional Programming With Java: Method References

Mon, 19 Sep 2022 00:00:00 +0000

Besides lambdas expressions, Java 8 introduced another language syntax change in the form of a new operator, :: (double colon), to create so-called method references.

BASHŌ (芭蕉) - An Exporter for Calibre

Mon, 03 Jan 2022 00:00:00 +0000

The first version of my Calibre export tool got released today!

Custom Operators in Swift

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

Swift is quite a flexible language, providing you with many tools to modify and augment it as you seem fit. One of these augmentations is the support for custom and overloaded operators.

Build-Time Variables in Go

Sat, 23 Oct 2021 00:00:00 +0000

Setting variables at build-time provides valuable metadata that wasn’t available when writing the code or even at runtime. We can control feature-flags, or build information, like a version number, without updating the Go-code constantly.

Java Interfaces vs. Abstract Classes

Wed, 31 Mar 2021 00:00:00 +0000

Even though interfaces and abstract classes have many similarities at first look, especially after introducing default methods, they have different use cases and capabilities.

Java Spliterator Explained

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

The concept of traversing elements with Iterators is supported since Java 1.2, but got a new relative in Java 8: java.util.Spliterator

How to Iterate with Java

Tue, 23 Feb 2021 00:00:00 +0000

Iterating data structures is one of the most common tasks. Everyone knows the classics, like for or while. But there are more ways to iterate in Java, providing a lot more functionality.

Essentials of Java’s Time API (JSR-310)

Thu, 07 Jan 2021 00:00:00 +0000

Dealing with date and time is a cumbersome task in many programming languages. But with Java 8, the JDK provides us with a comprehensive and completely new API, changing the way we deal with time-related concepts.

Functional Programming With Java: map, filter, reduce

Wed, 30 Sep 2020 00:00:00 +0000

The concept of map/filter/reduce is a cornerstone of any functional programming. Data pipelines consist of one or more intermediate operations that represent one of these three methods.

Local Variable Type Inference in Java 10

Thu, 20 Aug 2020 00:00:00 +0000

Java is often criticized as being too verbose. One aspect contributing to this characterization is the requirement to specify every type explicitly, which leads to a lot of additional noise.

Localization Changes in Java 9

Tue, 21 Jul 2020 00:00:00 +0000

java.util.Locale is used to format dates, numbers, currency, and more. But with JDK 9, a few changes were introduced, leading to subtle (and sometimes not so subtle) bugs.

Why We Should Build Our Own Tools: The Story of Tortuga

Fri, 17 Jul 2020 00:00:00 +0000

As developers, we perform many repetitive tasks, big and small. Many of these tasks might be made easier by using an appropriate tool instead. So let’s build them ourselves!

9 Tips For Writing Safer Shell Scripts

Sun, 05 Jul 2020 00:00:00 +0000

Shell scripting is a powerful tool available on all platforms, even Windows, thanks to WSL. But it can be easy to make mistakes. Here are some tips to improve our scripts and avoid many problems.

Nested Classes in Java

Mon, 29 Jun 2020 00:00:00 +0000

OOP allows us to nest classes that are logically bound together, to increase encapsulation, for more concise and maintainable code. Here’s a quick, non-deep-dive overview of the 4 types of nested classes in Java.

Functional Programming With Java: Exception Handling

Tue, 23 Jun 2020 00:00:00 +0000

Dealing with Exceptions in Java is a must, and functional programming doesn’t make it easier. Let’s take a look at the available options.

Java Benchmarks with JMH

Wed, 10 Jun 2020 00:00:00 +0000

Almost every developer knows the phrase “premature optimization is the root of all evil”, coined by Donald Knuth in 1974. But how are we supposed to know what is worthy of being optimized?

Choosing the Right Data Types

Mon, 08 Jun 2020 00:00:00 +0000

When we create a new data structure, deciding on its data types is usually a simple decision: text will become a String, non-floating-point numbers will be int, and so forth. But is it the right choice?

All You Ever Wanted to Know About Java Exceptions

Sun, 17 May 2020 00:00:00 +0000

Exception handling is a mechanism used to handle disruptive, abnormal conditions to the control flow of our programs. Let’s take a deep-dive how Java deals with them.

How Fluent Interfaces Can Lead to More Meaningful Code

Mon, 20 Apr 2020 00:00:00 +0000

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.” –Martin Fowler

Formatting Strings With Java

Tue, 14 Apr 2020 00:00:00 +0000

We all know String.format(...). But there are other options. Java has multiple ways of formatting, aligning, padding, and justifying Strings.

Utility Classes of the JDK: Dealing With I/O

Fri, 27 Mar 2020 00:00:00 +0000

Java NIO (“non-blocking I/O”) is a great feature set for dealing with I/O operations. Introduced by Java 1.4, it was further improved in Java 7.

The JDK Ecosystem

Thu, 26 Mar 2020 00:00:00 +0000

About 10 years after Java’s inception in 1996, Sun Microsystems released OpenJDK in 2007, a free and open-source implementation of Java SE. Many companies started to join as contributors.

Utility Classes of the JDK: Collections and Arrays

Tue, 10 Mar 2020 00:00:00 +0000

The JDK is evolving with every new release, adding more and improving existing features. Beneath the surface are hidden gems that make our lives much easier.

Decouple Your Code With Dependency Injection

Tue, 25 Feb 2020 00:00:00 +0000

Not many components live on their own, without any dependencies on others. Instead of tightly coupling them, we can improve the separation of concerns with dependency injection (DI).

JShell, the Java REPL

Wed, 19 Feb 2020 00:00:00 +0000

Many languages contain a REPL, a Read-Evaluate-Print Loop. It evaluates declarations, statements, and expressions as they are entered and immediately shows the results. With Java 9, we finally got one too.

10 Git Tips To Save Time And Improve Your Workflow

Mon, 17 Feb 2020 00:00:00 +0000

Git is packed with features and some can be very intimidating. So we resort to just using the same few commands we can memorize, over and over again.

Functional Programming With Java: Immutability

Sun, 16 Feb 2020 00:00:00 +0000

Immutability is one of the core concepts of functional programming. “Fully” functional programming languages support it by design, at a language-level. But in Java, we need to design and implement it ourselves, at code-level.

Habit-Driven Development and Finding Your Own Style

Fri, 07 Feb 2020 00:00:00 +0000

By designing and writing code, we naturally start to develop our own personal style and habits, good and bad. The more code we write with the intent to improve, the better we’ll get eventually.

Functional Programming With Java: Streams

Tue, 04 Feb 2020 00:00:00 +0000

Java 8 gave us the Stream API, a lazy-sequential data pipeline of functional blocks.

Java Annotations Explained

Mon, 27 Jan 2020 00:00:00 +0000

With JSR-175, Java 5 gained a metadata facility, allowing us to annotate our code with decorative syntactic metadata.

Functional Programming With Java: What’s in the Box

Tue, 21 Jan 2020 00:00:00 +0000

Java’s new functional abilities come with a plethora of included types. Let’s take a look into the box of provided tools.

Equality and Comparison in Java: Pitfalls and Best Practices

Wed, 15 Jan 2020 00:00:00 +0000

Java has different methods of comparing objects and primitives, each with its own semantics. Using the “wrong” one can lead to unexpected results and might introduce subtle, hard-to-catch bugs.

Functional Programming With Java: An Introduction

Wed, 08 Jan 2020 00:00:00 +0000

Java is a general-purpose programming language with class-based object-orientation at its core.

But, with the release of version 8, a more functional programming style became viable.

Java Stream Collectors Explained

Thu, 02 Jan 2020 00:00:00 +0000

With Java 8 came one of the greatest additions to Java: the Stream API. And one of its important aspects is collecting its results.

I (don’t) want to be a Digital Nomad

Wed, 01 Jan 2020 00:00:00 +0000

For a long time, I wanted to be more like a digital nomad: traveling the world and working wherever I got wifi. But after some trial runs, my views changed.

Introduction to CSS Custom Properties

Tue, 24 Dec 2019 00:00:00 +0000

Since its proposition in 1994, CSS has evolved from a static description of simple styles to a cornerstone of modern web design.

Bikes, Yaks, Airplanes, and Arguing About Unimportant Things in Engineering

Thu, 19 Dec 2019 00:00:00 +0000

The human mind loves to simplify concepts to more natural, understandable terms. That’s why bike sheds, shaved yaks, and airplane landing strips can teach us something about software development and project management.

Better Null-Handling With Java Optionals

Tue, 17 Dec 2019 00:00:00 +0000

Until Java 8, there was no better way to handle null references than checking your variables at every turn. The new class java.util.Optional<T> changed that significantly.

Know Your Dependencies

Wed, 11 Dec 2019 00:00:00 +0000

Almost no software project lives isolated without dependencies. The spectrum goes from “just use the stdlib” up to “use dependencies for every single line of code”.

DIY Swift Package Manager Dependencies

Mon, 09 Dec 2019 00:00:00 +0000

What to do if your favorite dependency is not SPM-compatible (yet)? We do it ourselves!

Signal-to-Noise Ratio

Fri, 06 Dec 2019 00:00:00 +0000

The signal-to-noise ratio is a measure used in science and engineering that compares the level of the desired signal to the level of background noise.

Best of: Java 8

Tue, 03 Dec 2019 00:00:00 +0000

We looked at version 7 of Java before. Now it’s time to look at its successor, Java 8, a really big update with lots of great new features!

Surface Pro 7 as portable Linux Dev Machine

Sun, 01 Dec 2019 00:00:00 +0000

I’m always looking for a small-footprint laptop for traveling supporting my Linux-based workflow. So naturally, I decided to use a machine with no first-class Linux support: a Surface Pro 7.

Column 80

Sat, 30 Nov 2019 00:00:00 +0000

Code lines shouldn’t be too long, and many of us use 80 columns as a (flexible) limit. But do you know why it is precisely 80, and not 60 or 120?

Best of: Java 7

Thu, 03 Oct 2019 00:00:00 +0000

Java was never the quickest language regarding new features compared to newer languages, but IMHO, this is one of the reasons why most of the enterprise world still depends on it and will in the future.

Moving from GitHub pages to self-hosted

Mon, 23 Sep 2019 00:00:00 +0000

Initially, this blog was hosted with GitHub pages.

It’s a great way to serve static content via Jekyll, but it lacks any traffic analytics if you’re not willing to include it yourself, which I didn’t want to.

Running a JavaFX app with Java 11

Sun, 22 Sep 2019 00:00:00 +0000

Thanks to the module system of Java 9 and the removal of JavaFX from Java 11, we got some problems running JavaFX apps without older versions of Java.

Naming Stuff is Hard: Why Proper Names Matter

Sun, 15 Sep 2019 00:00:00 +0000

Good and clean code starts with proper names. It’s not easy to name every little thing in a concise and meaningful way, but it’s worth the effort.

(Not) Everything needs JavaScript

Sun, 16 Sep 2018 00:00:00 +0000

Working with JavaScript is easier than ever before. The ecosystem is continuously expanding, and the entry bar is lowering.

But is this actually a good thing?

Your Comments Are Bad

Sun, 05 Aug 2018 00:00:00 +0000

Comments help readers to more easily understand code better by explaining our intentions, clarifying, or annotating it. But we tend to comment too much on the wrong things and too little on the right things.

How to Hotfix Carthage Dependencies

Mon, 12 Jun 2017 00:00:00 +0000

We’ve all been there: One of our dependencies is just a little off for our needs. There might be a decision by the developer we don’t agree or even a nasty bug. What should we do now?

Java for Shell Scripting

Mon, 20 Feb 2017 00:00:00 +0000

No matter what your daily driver is, most of us also have to write some shell scripts to automate stuff. Usually, bash script, Python, Perl, etc. is used. But what if we could use a compiled language instead?

Java 8 Interfaces: default Methods for Backward Compatibility

Wed, 01 Feb 2017 00:00:00 +0000

A new addition to the Java repertoire are default methods for interfaces: Non-abstract methods directly in an interface.

Java Streams: Order Matters

Tue, 20 Dec 2016 00:00:00 +0000

Streams are one of my most used features of Java 8, especially in combination with lambdas. They make code more concise, and we all love shorter, more readable code. But a lot can go wrong along the way.