Alien Invasion

Starting in summer 2010 (uh, was it really that long ago?) a couple of friends and me started developing a small game just for fun. We wanted to do it from scratch to have total freedom and to learn something in the process. To keep things simple, we chose to create a Space Invaders clone. We did this in our free time casually aside from studying or working, so it took a little bit longer than it would usually take. The most parts were finished during the course of 2011, including the first graphical assets. In the following years, there were some pauses and times of slow progress alternated by times of higher productivity.

Basically, the game was finished by the end of 2011. But as the rule of 80-20 (also called the Pareto principle) suggests, 80% of the time is consumed by the last 20% of the project. So during 2012 until now, most of the team was busy with life, but we still kept at it, polishing and refining the game until we were satisfied. Only a few graphical assets are missing (like proper laser graphics when shooting, a sprite for the mystery ship and a nice looking in-game HUD), but we decided its time to move on to other projects and finish this one.

Alien Invasion

Alien Invasion is entirely written in C#, using DirectX 10 with SlimDX and a self-made rendering engine, asynchronous resource management, the FMOD audio engine and utilizes a component-based game architecture. We even have a little LISP interpreter for our resource files! (yes, we are totally aware that this is absolute overkill for a small game like that. But as I already said before this wasn’t about the game, it was about the experience and trying stuff we wanted to do 🙂 )

So, without further ado, here’s the game:


Alien Invasion by Starforge Games is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.

Creative Commons License

To build and run the source code, you need Visual Studio 2015. Additionally, you have to copy the “data” folder from the game into the “AlienInvasion” project folder.


As of 11.06.2016, the project can also be found on GitHub at the following location:
Have fun with it. 🙂


In order to run Alien Invasion, you need the .NET Framework 4.6. Additionally, you may need to install the SlimDX End User Runtime for .NET 4.0, available on the official SlimDX website in the download section.


I would like to express my sincerest gratitude to all people who contributed to this project. These are, in no particular order:

My special thanks goes to Hansheinz Müller Philipps Sohn for providing the server infrastructure.

Master Thesis: Modality-independent Exchange of Information Across Devices Using the Pick-and-Drop Concept

I have submitted my master’s thesis to the university of Ulm and received my master’s degree. The task of my master thesis was to develop and evaluate a multimodal user interaction concept for an existing prototypical system that allows a drag-and-drop-like interaction across device borders.

To make things more interesting, this is no ordinary drag-and-drop action where the dragged information must retain its original representation. The dragged information can be dropped and represented by different media types, depending on the context. An example would be to drag the text “apple” and drop it into a droppable area for images. The dragged information would then adapt by switching to an image of an apple and displaying the visual information. One of the main achievements of my master’s thesis was to devise such an interaction concept and discuss the implications and problems inherent to such interaction possibilities.

Another point was the ability to spontaneously switch input modalities and devices on demand. For example, when working with a computer using mouse and keyboard to input information the user should be able to leave the computer, pick up a tablet and continue working in the next room inputting the text utilising the touch pad or voice input of the tablet.

Alas, I cannot share the source code this time, as my prototype is heavily dependent on the existing prototypical system and interweaved with its code, which is the property of the university of Ulm and part of a larger research project. But, as the focus was the interaction concept and its theoretical elaboration, the most interesting parts of this work can be found in the documentation.



It was written to the best of my knowledge, though I can’t guarantee it’s perfectly free of errors. Furthermore, the disclaimer of this blog applies.

Meilensteine des Software-Engineering: Prinzipien der Modularisierung

Another post in german, since I had to write this paper in german (requirement by my professor).

Ich hab’ dieses Semester ein sehr interessantes Seminar an der Universität Ulm besucht über Meilensteine in der Geschichte des Software-Engineering, welche Themen behandelten wie diese Disziplin entstand und welche definierenden, richtungsweisenden Beiträge über die Zeit entstanden. Mein Thema war die Modularisierung von Software und nach welchen Prinzipien und Kriterien hierbei vorgegangen werden kann.

Modularisierung ist eine essentielle Methode in der Softwareentwicklung um komplexe Probleme beherrschbar zu machen, die Flexibilität von Software zu erhöhen und ihre Wartbarkeit zu erleichtern. Welche Prinzipien & Kritieren können angewandt werden um zu einer optimalen Modularisierung zu gelangen? Gibt es überhaupt eine optimale Modularisierung oder müssen gewisse Vor- und Nachteile gegeneinander abgewogen werden um die gesteckten Ziele eines Softwaresystems zu erreichen?

Was der große Vorteil der Modularisierung von Softwaresystemen ist und welche Kosten eine Modularisierung mit sich bringen kann soll in der vorliegenden Arbeit beleuchtet werden. David Parnas veröentlichte 1972 einen Artikel mit dem Titel ‘On the Criteria To Be Used in Decomposing Systems into Modules’ [1] und führte ein wichtiges Prinzip ein: Das information hiding.

Die Auswirkungen von Parnas’ Artikel auf den heutigen Stand, auf andere Prinzipien, Ratschläge und Design Patterns, zu denen sich in Parnas’ Artikel bereits Ansätze erkennen lassen, sollen in der vorliegenden Arbeit ausgeführt werden.


Paper on API Evaluation

I wrote a paper on the very intriguing topic of API Evaluation, which is often overlooked or simply unknown to many software developers. The paper aims to give an overview over the topic and currently available and researched techniques to evaluate APIs. Here’s the abstract:

Application Programming Interfaces (APIs) are the “glue” between software components. Almost all developers work with APIs on a regular basis in one form or another, making APIs one of the cornerstones of modern software development. Still, evaluating and ensuring API qualities is an often overlooked topic. In the past years, a lot of research has been going on with the goal to come up with better evaluation techniques and metrics to assess the qualities of APIs.

This paper analyses the current state of research. It starts with an introduction to the problem and gives an overview of five recent proposals for API evaluation techniques. Every technique is introduced, described both in terms of necessary preparations and the actual execution and concluded by a summary that highlights benefits and drawbacks of the technique. Closing, a conclusion provides an overview of the state of API evaluation techniques based on the five techniques reviewed in this paper.

I also gave a presentation on the topic. Alas, the slides are only availabe in german.



The beautiful photos on the first and last slides were taken by Hansheinz Müller Philipps Sohn, a talented hobby photographer and good friend of mine. They were, of course, used with his permission.

Bachelor Kolloquium

This time, for once, a post in german.

Geschafft! Am 26.10.2010 gab ich nun letztendlich mein Kolloquium (Präsentation meiner Bachelorarbeit) im Rahmen der Vorlesung Aktuelle Themen der IT-Sicherheit. Mein Vortrag war sehr gut besucht mit ungefähr 80 Studenten aus dem 1., 3. und 6. Semester Informatik, sowie von ein paar Studenten des Elektronik-Masters wie ich am Tag darauf beim Kendo Training erfahren hab (Stichwort: Die Welt ist klein).

Die Präsentation hab ich an meiner Hochschule, der HTW Aalen, auf deutsch gehalten und dem unmittelbaren Feedback mancher Teilnehmer, die auf mich zukamen nach der Präsentation, zu schließen kam Sie auch ganz gut an. 🙂


Im Folgenden die Präsentation, jeweils im PPTX und PDF Format:

Hell, it’s about time…

So, I will be starting off with a quote from StarCraft 2 – which I found to be quite fun once you get over the stressful starting phase on the 😉

There was not much going on here over the course of the last year for I was busy working on different kinds of things, one of them being my bachelor thesis and getting my degree. As of this month, I finished my thesis, so there will be coming more in the future as I finally got some spare time to pursue projects in my spare time.

Let the games begin!

One of those projects I wanted to pursue for a very (very very) long time is game programming. Actually, that’s what got me interested in programming in the first place. Strange thing I didn’t try it earlier, don’t you think?

Anyways, better late than never and I’ve been working on a Space Invaders-clone for the past weeks with some dear friends of mine. Now, Space Invaders does not sound too exciting, but everyone has to start by taking little steps, and those are mine.

On the other hand, this little game won’t be coded in a quick’n’dirty manner, but with a fully-blown component-based architecture backing it up (and a hell of a threaded resource manager written by Patrick Bader), so it’s not too trivial on the technical side of things. I plan on releasing the source code (it’s written in C# utilizing SlimDX, btw) when its finished, so look forward to it if you’re a programmer interested in game architectures.

As a gamer, you may also look forward to it as this game will feature some nice sprite graphics created by Daniel Kwast and Isolde Scheurer.

Bachelor Thesis: An Android App for One-Time Password Generation & Management

The full title of my bachelor thesis is “Development of an Android App for One-Time Password Generation & Management“, which was shortened for the title. I developed an Android app that allows the user to carry and manage any number of OTP lists, specifically OTP lists created by the OTPW Package written by Markus Kuhn. The thesis consist of the app itself as well as a theoretical document covering One-Time Passwords in general, Random Number Generation, the Android platform, app development for Android and, last but not least, the actual app development itself.

The app utilizes the GNU Crypto library. Alas, the Android Development Tools (ADT in short) could not convert the JAR library file provided by the GNU Crypto website into an Android-compatible JAR file, so I had to include the source of the GNU Crypto project itself. To limit the impact on the size of the app, I only included what was needed by my app (the hashing facility) and left out the rest of the GNU Crypto project.

Though primarily written to manage and generate lists of the OTPW package right now, the app architecture was designed with extensibility in mind. It should not be too hard to add support for another OTP-System. The basic components are well encapsulated and the generation facility was written in a way that allows new classes to be added to handle other OTP systems. Only the generation GUI needs to be extended to accommodate for other possible OTP-Systems.

Future development

For the time being I won’t continue working on this app. Also, I did not distribute it in the Android Market as you need a credit card to do so and – though some might not believe it – I don’t have one. If you are interested in continuing the development of this app, feel free to contact me so we can talk about it. I’m sure we will be able to come to an agreement.



It was written to the best of my knowledge, though I can’t guarantee it’s perfectly free of errors. Furthermore, the disclaimer of this blog applies.

Project work on genetic algorithms, the TSP and parallelism

Over the course of the last semester I did a project work with the title ‘Approximation of the Traveling Salesman Problem utilising a genetic algorithm in a parallel system‘. As this is a very complex title by itself, I will explain what this work was about in a few sentences. For further details please take a look at the documentation.

The main goal of this project was to develop an algorithm to approximate an optimal tour for the traveling salesman problem, which is in short as follows: A salesman wants to visit X cities under the following conditions:

  • every city must be visited exactly once
  • the tour has to be a round trip

This is a NP-complete problem, meaning there is no efficient algorithm known to solve it in a worthwhile timeframe. Since nobody wants to wait for several years to get an optimal tour, there are some approximation algorithms which are rather good. As multi-core processors are becoming more and more common, programming applications that utilize multiple cores has become an important trait.

This is where genetic algorithms come into play: Offering intrinstic parallelism they’re well suited for parallelization. Also, they are very general in nature: All that’s necessary is to encode the problem in a way the genetic alorithm can handle it. The algorithm does not need any problem-specific information, although it could be used to enhance the results.

The TSPLib was used for sample data, which is pretty nice as there are best known solutions to it.

Build Environment

The program was developed in Linux using eclipse CDT 5.0.1 and CMake 2.6, so this is the recommended environment to build and run it. It also utilizes OpenMP and TR1 for shared pointers, so make sure your compiler supports it. For further details, see How to build.

Building under Windows

By default the build environment is set to linux to compile. If you want to compile it under windows, you have to set the appropriate define in the config.h file:

//#define LINUX
#define WIN_32

Also note that this is a console application, so make sure you’ve set your IDE to the correct system.



It was written to the best of my knowledge, though I can’t guarantee it’s perfectly free of errors. Furthermore, the disclaimer of this blog applies.

Mech Heat Tracker

As my application for the MechWarior: Living Legends Crysis Mod (which was successful, btw 😉 ), I had to implement a Mech Heat Tracker. I was given a template to work from—a class with a couple of method and attribute declarations—and had to work out the implementation details all by myself. I was only given a few instructions (see MechHeatTracker.h).

Basically, this is a simulation of a two-legged combat vehicle called ‘BattleMech’ (in short ‘Mech) which generates lots of heat while fighting. ‘Mechs are equipped with heat sinks to dissipate the excessing heat they are generating. When the excess heat is just too much the heat sinks to cope with they can flush coolant to increase their cooling rate, as long as the coolant tanks don’t run out of it. Heat sink’s effectiveness is affected by the environment (they have a harder time to dissipate heat in the sahara as they would have at the north pole). Also, if the heat exceeds a certain threshold, the heat sinks may take some damage—when they are, their effectiveness is affected.

You can take a look at my implementation by downloading the source files given in the download links below. I’ve also created a little test program (Windows binary), which just generates some random input data for the Mech Heat Tracker and prints the results to the console.


Security mechanisms in Linux

In my 4th Semester, I have written an introduction on Linux security mechanisms on application level. This introduction covers topics like Access Control techniques, hardening the linux kernel, the LSM Framework, SELinux and AppArmor, as well as Ruleset Based Access Control.

I want to emphasize that this work is only an introduction on the topic and therefore does not contain manuals or step-by-step tutorials on how to set those features up, rather explaining how they work as well as elaborating their advantages and disadvantages.



This document was completely written in german. There is no english version available. It was written to the best of my knowledge, though I can’t guarantee it’s perfectly free of errors.

Go to Top