My Universe

Pilatus PC-12 X-Plane Wallpaper

Fri, 14 Feb 2025 16:54:59 +0100

I was asked to share this wallpaper – well, here you go. You can download the image in full resolution here: Thranda PC-12 Wallpaper (2560×1440)

Installation for X-Plane 12 is easy: just place the .png file into the Output/backgrounds/ folder of your X-Plane installation.

Configuration to Go

Sat, 06 Apr 2024 00:00:00 +0000

One of the boilerplate tasks for nearly every (application development) project is the implementation of an application configuration management. In most cases, applications have aspects we want to be configurable, e.g. the port a server listens on, the language an UI starts with or the database connection an application shall use. The twelve-factor app methodology propagates using environment variables for this purpose, but what might be a good idea for cloud-deployed web apps won’t work equally well for desktop applications or in traditional deployment scenarios. For them, more traditional ways like configuration files or command line flags might be a better choice.

Elegant Python Exceptions

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

Particularly when creating library packages in Python, raising exceptions is a great way to let the downstream developer know about problems occuring while executing code from within the library. Python’s built-in exceptions cover a whole host of cases. However, some problems might be library-specific and deserve a custom exception.

Custom Exceptions

Creating a custom exception in Python isn’t particularly hard when observing a few rules:

Custom exceptions shall be derived from Python’s Exception class
By convention, exception names shall end with “Error”

1class MyLibError(Exception):
2 pass

In many library packages, you will find exceptions similar to the one shown in the code example above. There’s nothing wrong with that; if chosen wisely, the exception name by itself will already tell what went wrong. However, the more details an exception provides about the circumstances it was raised in, the easier to diagnose and debug the problem, and the more appropriate the reaction to an exception.

Dataref Caching Revisited

Wed, 27 Sep 2023 00:00:00 +0000

Earlier this year I wrote about caching datarefs. Back then we only looked at caching single datarefs, which quickly leads to bloated code once applied in a wider context. So here we are again, taking a closer look at caching many datarefs efficiently.

What About Trees

“Are we going to leave those poor little Datarefs here in this horrid, dark, dank, tree-infested — I mean… charming, quite charming, forest?”

— unknown dwarf coder

Configuration File with XPPL

Sat, 23 Sep 2023 00:00:00 +0000

In this blog post we’re looking into using XPPL to enhance a plugin with a configuration file. Working with XPPL’s configuration module is follows this five-step sequence:

initialize a configuration context
register configuration properties
load the configuration file
access the configuration values
clean up

First, we need a configuration context. Since we will need to keep it alive throughout the whole plugin life cycle, we declare it as static, global variable:

Introducing XPPL

Fri, 22 Sep 2023 00:00:00 +0000

Are you tired of (re-)writing the same boilerplace code for every X-Plane plugin project — over and over again? Well, at least that’s how I felt when I started my fourth or fifth plugin. Sure, I reused a lot of my boilerplate code, but with every project, I refined and enhanced it. Backporting those changes to older plugins became a tedious task though; therefore I started the X-Plane Plugin Library (XPPL).

Cache Your Datarefs

Thu, 20 Apr 2023 22:20:48 +0200

Nearly every X-Plane plugin accesses one or several of X-Plane’s datarefs at runtime. It’s not uncommon to find code like this:

1void set_data(float value)
2{
3 XPLMDataRef dref = XPLMFindDataRef("what/ever/data/ref/we/need");
4 XPLMSetDataf(dref, value);
5}

Admittedly this works. However, there are a couple of reasons why the code above is not the best idea, if you’re seeking to write a solid and well-performing plugin:

Talk to the Log

Sat, 14 Jan 2023 19:51:48 +0100

Making an X-Plane plugin “talk” to us is one of the boilerplate tasks when setting up a new plugin project. X-Plane has its own log file, log.txt, which is found in X-Plane’s root folder. The file gets reset every time X-Plane starts, so there’s no need to rotate or trim it from time to time. As a plugin author, we have the choice to either write our own log file, or to jump on X-Plane’s bandwagon and use its logging system for our purposes. While I can see the benefits of having a dedicated logfile for a plugin, personally I prefer to use X-Plane’s built in logging mechanism – there are technical reasons, but mostly it’s a comfort and usability decision: most X-Plane users will immediately think of the central log.txt file when a developer asks them to provide their log file (e.g. when reporting an issue).

CMake Linux Hack

Wed, 11 Jan 2023 00:16:46 +0100

Beginning with its most recent version (3.25 at the time of writing this post), CMake provides the LINUX variable, which I used in my previous post. Of course, developers on Linux tend to use the version of CMake they can install from their distribution’s package manager. On Ubuntu 22.04 LTS that would be 3.22, and even on the most recent Ubuntu version (22.10) we’re at 3.24 — meaning this variable is not available in these CMake versions.

X-Plane Plugin Boilerplate

Wed, 04 Jan 2023 15:28:28 +0100

X-Plane has a well-documented, accessible API, making it relatively easy to write plugins for the simulator. In this post I’m going to demonstrate how a basic plugin boilerplate can look like, and how to build it on different platforms.

Let’s get started with some basics: X-Plane plugins are dynamically linked libraries, which are loaded by X-Plane at runtime. They have to provide an API as defined by the X-Plane SDK, so X-Plane can access the plugin via defined entry points. The API documentation explains all this, and also provides examples for basic and more advanced plugins. For this post I am going to use a very barebone plugin which does nothing except existing in X-Plane.

Reload 2023

Tue, 03 Jan 2023 21:19:03 +0100

More than five years without new content — that’s a new sad record, even for me. Time to change things. While originally this site was set up to run with HubPress, it never really worked up for as well as it promised in the beginning. Working with HubPress was hit and miss — for me it frequently lost its session context, losing some work done. Also it was pretty picky which browser it worked with. And finally, in 2019, HubPress got shut down. The GitHub repo is still around (archived, i.e. read-only), so there’s no hope the pending issues will ever see a fix.

Colours in Django Models

Wed, 08 Nov 2017 00:00:00 +0000

Colours are quite a common property to real world objects. So naturally when building web applications, sooner or later one encounters the need to assign a colour attribute to an object. For Django developers, this usually means adding a models.CharField to their model, ready to capture the colour’s hex code.

Technically this works pretty well, as those hex codes can directly be used in HTML style attributes, embedded SVG drawings, etc. However, setting colour values via text input widget is quite tedious. On the frontend side, various libraries offer quite elaborate solutions for integrating nice colour picking widgets. For the Django admin, there is however a quite simple solution: use HTML 5 color inputs!

Pythonic Distance Conversion

Sun, 28 May 2017 00:00:00 +0000

When dealing with distances or lengths, it’s a common problem to convert values between all the different units available out there. Of course, converting itself is a less than complicated simple floating point division or multiplication, depending on how values and conversion factors are stored internally. However, maintaining conversion factors all across a project is a tedious task, and Python has some good means at hand to simplify our life.

GitFlow Groundhog Day

Tue, 02 May 2017 00:00:00 +0000

Yes, this is all over again the old discussion about what’s the best branching model for projects using Git as their version control system. I know, there are countless blog posts (e. g. 1, 2, or 3) about that topic out there… yet, I feel most of the discussion is focused on projects with continuous deployment (i. e. mostly web applications), whereas classical desktop software with classical release cycles are rather underrepresented.

First, some thoughts on what I actually need, before creating any new ideas others put already in the bin due to being unfit… When hacking on a desktop software or an operating system (i. e. something that will be deployed on many systems, by many people, without me as developer being aware), it all comes down to releases. People are used to releases, updates etc. being clearly labelled with a semantic version designator. This is no different from what you should do for SAAS web applications — what’s really different here is that for desktop applications, several supported versions can exist in parallel. So for me, a good branching model should

Reboot

Sun, 30 Apr 2017 00:00:00 +0000

I amar prestar aen,
Han mathon ne nen,
Han mathon ne chae
A han noston ned ‘wilith

And again, my world is changing. A bit more than one year ago, I moved from a self-hosted blog built with Ghost to a fully managed website using Jimdo’s website construction kit. Sure, the effort for maintaining the full stack (server, os, database, web server software, etc.) has gone, and I certainly don’t want it back.