You can't do X under pressure!

A simple game built while learning Cordova and AdMob.

You can pick questions from up to six mathematical categories ranging from simple arithmetics to more complex analysis. While playing you earn XP to unlock more content. From time to time and based on your achievements you may watch an ad video to double the XP you earned in that session.

Impressions:

• Date: 2017
• Technologies: JavaScript, CoffeeScript, Phaser, jQuery, admob, grunt, cordova
• Platform: Browser
• Context: Hobby Project

Stencil Partitioning

A small project to generate the optimized stencil partitioning schemes that we found in the Evolving Stencil Partitions project as well as a variety of state-of-the-part partitioning schemes.

This project is available on GitHub.

Impressions: View Live:

Features:

• 5 Partitioning Schemes for 8 Processores/Cores/Machines
• 4 Partitioning Schemes for 4 Processores/Cores/Machines
• Configurable UI
• Generating Pdf-files with one-click
• Performance Diagrams for different Problem Sizes

• Date: 2016
• Technologies: JavaScript, CoffeeScript, Phaser, jQuery, jsPDF
• Platform: Browser
• Context: Research Project

Wonderland

Down the rabbit hole

First steps towards a more sophisticated ecosystem simulation. Currently only biomes and plants are simulated - in future versions animals and finally simple human agents are planned. The idea is to extend the sugarscape model by agents having different characteristics instead of the monoculture of the original model.

The soil has different properties depending on location: more minerals in the center, more water towards the edges. Plants will grow and reproduce to fill all adjacent biomes that meet their needs. Growth rate depends on mineral level and water accessibility.

This project is available on GitLab.

Impressions: View Live:

• Date: 2016
• Technologies: JavaScript, CoffeeScript, Phaser, jQuery
• Platform: Browser
• Context: Research Project, Hobby

Sugarscape 3D

Sugarscape 3.0

This project was inspired by the book "Growing Artificial Societies: Social Science From the Bottom Up" by Joshua M. Epstein.

The idea behind the sugarscape model is to show that astonishingly complex systems can emerge from a set of very simple rules. Furthermore, the book argues that the sophisticated phenomena of social sciences and economics can be modeled more precisely with these simulations than with the then-prevalent mathematical models. In contrast, sugarscape agents exhibit a variety of active processes at the same time, which are usually disregarded in mathematical models, such as aging, movement, friendship, and diseases.

This project is available on GitLab.

Impressions: View Live:

• Date: 2015
• Technologies: JavaScript, CoffeeScript, ThreeJS
• Platform: Browser
• Context: Research Project, Hobby

Sugarscape 2D

This project was inspired by the book "Growing Artificial Societies: Social Science From the Bottom Up" by Joshua M. Epstein.

The idea behind the sugarscape model is to show that astonishingly complex systems can emerge from a set of very simple rules. Furthermore, the book argues that the sophisticated phenomena of social sciences and economics can be modeled more precisely with these simulations than with the then-prevalent mathematical models. In contrast, sugarscape agents exhibit a variety of active processes at the same time, which are usually disregarded in mathematical models, such as aging, movement, friendship, and diseases.

This project is available on GitLab.

Impressions: View Live:

• Date: 2015
• Technologies: JavaScript, NoiseJS
• Platform: Browser
• Context: Research Project, Hobby

Evolving Data Partitionings

This project was inspired by the PhD thesis "Optimal Data Partitioning Shape for Matrix Multiplication on Three Fully Connected Heterogeneous Processor" of Ashley Deflumere

In her thesis, she demonstrates that the state-of-the-art algorithms to partition input data for matrix multiplications can be greatly outperformed my non-rectangular partitioning shapes. The algorithm she uses is very resource intensive and for this reason currently restricted to three processors. In this project, I wanted to see whether this principle could be applied to other algorithms, as well. Since the algorithm by Ashley Deflumere only worked for matrix multiplications, we used machine learning algorithms to evolve solutions for arbitrary algorithms.

Stencil computations were our first target, since they are also one of the Berkeley Dwarves. Indeed, we found a partitioning scheme for stencil operations on four processors that outperformed all alternatives.

In later projects, Marius Knaust and I optimized and generalized the solution. Based a geometric evolutionary approach, we studied optimal stencil partitions for up to 12 processors.

This project is available on GitHub.

Impressions:

• Date: 2015
• Technologies: C#, LINQEx, WriteableBitmapEx.Wpf, Evolutionary Algorithms, Machine Learning
• Platform: .NET Framework
• Context: Research Project, Hobby

KOSM: Automating Rocket Science

We were looking for challenging virtual experiments to accompany our physical ones, so we looked into games which teach interesting physics concepts and found Kerbal Space Program (KSP). In order to allow our students to run their own code on these virtual rockets, like they would on our other experiments, we created a framework to run C# code inside a plugin for KSP.

Based on this framework we implemented an autopilot that could execute a number of maneuvers very accurately and even execute some missions - such as launching, getting the rocket into a stable orbit, aerobraking safely and landing again. We hosted a Twitch channel for this autopilot and it was running on our group's public display for some time.

We intended to use Machine Learning, especially Genetic Programming, to automatically improve the autopilot and develop it into a super reliable fallback system that can detect problems with a student's code and save the rocket. In the end, this turned out to be a very time-consuming endeavour and other projects won the fight for our time budget. ;)

This project is available on GitHub.

Impressions:

• Date: 2015
• Technologies: C#, Unity, Kerbal Space Program
• Platform: Unity
• Context: Research, Lecture and Hobby Project

Interactive Delta-V Map for Kerbal Space Program

A small hobby project to transform the static delta-v maps for KSP into an interactive webpage. It turned out to be a very popular tool for the KSP community which still has about 100 visits a day :)

This project is available on GitHub.

Impressions: View Live:

• Date: 2015
• Technologies: Javascript, Bootstrap
• Platform: Browser
• Context: Hobby Project

Dominion: Computer Science Edition - Steampunk Style

This is an adaption of the famous card game Dominion by Donald X. Vaccarino. Instead of the original medieval theme, my version features terms from the computer science domain, e.g. Compiler, ENIGMA, Linus Torvalds, etc. The visual style is inspired by Steampunk.

Most of my cards are basically modifications of cards invented by Donald X. Vaccarino that were mapped onto the computer science domain. In addition to inventing new names for everything, I slightly changed the details of some cards, added a new card here and there and introduced two new types of curse cards. Then I got creative and toyed around with a completely new class of cards: Mentor cards are played like action cards, but unique and way more powerful. Most of them are single use, while others provide boni as long as they are placed on the table. There are different ways to integrate them into the game, some of which change the experience complety while others only add a moderate component of chance to the game.

Impressions:

Features:

• 80 unique Mentor cards
• 55 types of kingdom cards with various categories like Dev Ops, Software Engineering, Computer, ...
• 12 types of Lines of Code cards (my version of victory cards)
• 4 types of Mythical Man Month cards (my version of treasure cards)
• 3 types of Malus cards (orginally coined curse cards)

• Date: 2014
• Technologies: Photoshop
• Platform: Tabletop
• Context: Hobby project

Numbers Android App

A very simple number guessing App.

This project is available on GitHub.

Impressions:

• Date: 2014
• Technologies: Android, Java, JavaScript
• Platform: Browser
• Context: Hobby Project

Rorschach Android App

This app allows you to create randomized, unique Rorschach images. What do you see in the inkblots?

This project is available on GitHub.

Impressions:

• Date: 2014
• Technologies: Android, Java, JavaScript
• Platform: Browser
• Context: Hobby Project

Cycles of War (JavaScript Edition)

Know. Think. Decide. Act.

This game is all about planets. Players try to acquire them all in order to win. Their only way of interacting, though, is to send a fleet from a planet they own to any other planet in the universe. When any of the fleets arrives at its target, an automatic battle will be fought the winner of which will be in possession of the planet afterwards. This is very convenient, because planets automatically produce troops that can then be send off to new worlds again.

The JavaScript addition is a quick rewrite of the beautiful Java version of the game.

This project is available on GitHub.

Impressions:

View Live:

• Date: 2014
• Technologies: JavaScript
• Platform: Browser
• Context: Hobby + Research Project

Fractal Flames

While working on the Fractal Explorer, I stumbled upon Fractal Flames, a very special Iterated Function System using a chaotic attractor, non-linear functions, log-density display and structural coloring. All the details about the algorithm can be found in "The Fractal Flame Algorithm" by Scott Draves and Erik Reckase.

My implementation integrates with the fractal explorer.

Impressions:

• Date: 2013
• Technologies: Java
• Platform: JVM
• Context: Hobby Project

Fractal Explorer

My fractal sandbox :)

Started as a test project for OpenCL acceleration of the noise computations for Cycles of War, the Fractal Explorer instantly began a life of it's own. It became a sandbox to play around, not only with noise algorithms, but also fractals. Later, Iterated Function Systems (IFS), Attractors, Buddhabrot were added.

It is a convenient framework to add new algorithms. Details can be explored interactively, functions can be combined, color schemes can be selected. Everything can be animated and captured to video.

This project is available on GitHub.

Impressions:

Features:

• OpenCL acceleration
• Interactive editor
• Fractals, Noise, Attractors, Iterated Function Systems, ...
• Animation and Video function
• Apply filters and combine functions

• Date: 2013
• Technologies: Java
• Platform: JVM
• Context: Hobby Project

Evolving Real-Time Mulitprocessor Scheduling Policies

Slack is not good enough :P

While working on a theoretical proof of the advantages of slack-based Real-Time Multiprocessor Scheduling with Lars Lundberg at the Blekinge Institute of Technology in Karlskrona, I wanted to see how more complex scheduling policies would perform. So I built a C# program that relies on Evolutionary Algorithms to evolve and test Scheduling Policies, which I iteratively improved over the following two weeks.

In his master's thesis, Christian Kieschnick and I re-implemented the framework in C++ and OpenMP, which allowed us to run the machine learning algorithms on Intel Xeon Phi accelerator boards.

This project is available on GitHub.

Impressions:

Features:

• Based on Evolutionary Algorithms, Machine Learning
• Comes with a variety of state-of-the-art schedulers to compete with
• Configurable workload generators for 8 classic problem classes
• 5 configurable workload generators for very challenging task sets

• Date: 2012-2014
• Technologies: C#, C++, OpenMP, Xeon Phi
• Platform: .NET Framework
• Context: Research Project

Game ERP

A straightforward "trade buddy" tool that helps users of an ingame trading post to manage their orders and offers. It allows filtering for profitable items, keeps a trading history, and offers statistics and buy recommendations.

Impressions:

• Date: 2012
• Technologies: C#, WPF
• Platform: .NET Framework
• Context: Hobby Project

Cycles of War

Know. Think. Decide. Act.

This game is all about planets. Players try to acquire them all in order to win. Their only way of interacting, though, is to send a fleet from a planet they own to any other planet in the universe. When any of the fleets arrives at its target, an automatic battle will be fought the winner of which will be in possession of the planet afterwards. This is very convenient, because planets automatically produce troops that can then be send off to new worlds again.

This game / artificial intelligence battleground was developed, because my fingers are too thick and too slow to beat a pretty similar game on my phone. So instead of fighting my touch display to make the phone carry out my cleverly laid out strategies, I wanted to be able to just write down the strategy and see it succeeding in a Ender-Wiggin-Like battle. So one long afternoon in the university I built the foundation for the project, followed by two more weeks of evenings in the flow, where the whole API was hardened and sparring bots were born. Since then the many brave students and collegues have thrown their champions into the arena to demonstrate their superity. Thanks to them we have a very fine selection of worthy opponents. Thanks to Markus, we furthermore have very beautiful optics now.

This project is available on GitHub.

Impressions:

Features:

• Various modes: interactive, demo, arena, duell
• Many themes: simple, fancy, galaxy, organic, big planet, and pretty
• Change the settings of the universe in the GUI
• Create your own rules with the rule engine
• Add your own champion and compete against more than 25 artificial intelligences!

• Date: 2011-2013
• Technologies: Java
• Platform: JVM
• Context: Hobby + Research Project

Hybrid.Net

GPU acceleration for free!

Hybrid.Net enables .NET developers to harness the power of GPUs for data- and compute-intense applications using the simple well-known construct: Parallel.For

The idea was to create a library that brings the huge performance potential of OpenCL-compatible devices to .NET developers without forcing them to learn new keywords. Our implementation looks exactly like the Parallel.For that ships with .NET 4.0 (and previously with the Task Parallel Library). It transparently translates the loop body to OpenCL code and executes it on available accelerators.

This project is available on GitHub.

Features:

• API similar to System.Threading.Tasks.Parallel.For (all you have to do is to exchange the namespace)
• Various modes: single-GPU, all-GPUs, single-CPU, all-CPUs, everything-avaialbe
• Multi-dimensional array support and an additional 2D version of Parallel.For

• Date: 2010-2013
• Technologies: C#, OpenCL
• Platform: .NET Runtime
• Context: Research Project

The Health App

... because health is the greatest good!

Due to the large number and variety of novel technologies there is a big innovative potential in these days: mobile phones are becoming more powerful and smarter each day. Mobile Internet is commonplace. Entertainment is everywhere, even on the road. But modern consumers want not only to be entertained. They want to experience knowledge and information in a light-weight, even playful, manner. Because of the prevailing flood of information, hardly anyone is able to filter, to collect and to keep up in a conventional way. This is why many things fall by the wayside: regular doctor visits, healthy and balanced diet, taking medicines on time, monitoring pollen forecasts, etc. If you belong to a risk group in which a comprehensive health surveillance of vital data can be indispensable to life, this is particularly critical. Often one wishes for someone who has a way through this chaos: A guide that is always there with a good tip and helps to think of everything.

This guide is the Cardea App. It provides useful situational tips to assist its users in their daily lives. In addition to health-conscious, sporty people, it also assists pregnant women, diabetics, people with heart diseases, allergy sufferers and many others by not only monitoring over medicine taking schedules and doctor visit appointments, but, for example, by measuring the weight / blood sugar trends, by showing the way to the nearest pharmacists or by warning against pollen-related headaches. It is the holistic solution for anyone who wants to live a healthy, active, long life.

The design follows the principle that needed and useful information is to be reached easily and fast, and that all functions are customized for the individual user.

On the bottom of every page are our standard features: Users can obtain more detailed information, check and modify their stored data and signal that they do not feel well and want appropriate advice. The actual functionality of these buttons depends on the user's previous usage history of the app and the currently opened view. For an allergic person, suffering often from headaches, the page will, for example, first show "Tips for a headache", then "Way to the nearest pharmacy" and finally "Tips for allergy sufferers.

All health related information has to be configured by the user’s physician in a user specific therapy. It is not our aim to provide medical advice but rather to present and enrich a prescribed therapy to the user.

The Health App is one of the winners of the Apps4Berlin idea competition.

Design Preview:

• Date: 2011
• Technologies: C#, Windows Phone 7
• Platform: Windows Phone 7
• Context: Apps4Berlin App Contest

NQueens with CUDA

GPU-accelerated solver for the NQueens puzzle

When I started with GPU computing, I wanted a apply it to a problem that was a little more sophisticated than a hello-world example. At the same time, the n queens problem has been in the news: the University of Dresden, Germany had just broken the world record with their custom-tailored FPGA boards. Turns out there are 22,317,699,616,364,044 valid ways to position 26 queens on a 26 by 26 check board, so that none is attacking another one.

So I picked the NQueens problem to see how far I could push a GPU-accelerated solution. I learned a lot about GPU computing, GPU hardware and discovered some very interesting performance anomalies. (Back then, GPUs were lacking all the convenient features they got in the recent years.)

Results:

• A paper about the implementation and some performance anomalies.
• A pretty fast CUDA-based NQueens implementation.
• A master thesis evaluation the design space for optimizations utilizing the Dynamic Parallelism features of 2014th NVIDIA GPUs.

• Date: 2010
• Technologies: C/C++, CUDA
• Platform: NVIDIA GPUs
• Context: GPU Computing Research

Evolutionary AI

Reviving my passion

After rage-quitting my first elaborate AI project in 2004 and regretting it ever since, I revived it in 2009. (After I deleted the project, I realized why it misperformed and how I could have easily fixed it...)

The fundamental idea was to use natural selection to evolve artificial brains - which is known today as Neuroevolution. I was trying to make my approach as generic as possible by allowing for way more variance and expressiveness in the neurons.

While I did make some progress, the results were never overwhelming and other projects became more interesting - and so my Evolutionary AI project started to collect dust. Looking back at the project, I see that, although I experimented with multi-tier neural networks, I just was not bold enough to scale them up to sizes that are used nowadays. Performance was just not as vast and accessible back then.

Impressions:

• Date: 2009
• Technologies: C#
• Platform: .NET Platform
• Context: Research Project

Math Christmas Calendar

A copmetition with multiple teams to realize a math christmas calendar

Microsoft held a competition to develop a Math Christmas Calendar for the editorial office "Year of Mathematics". As our contribution to this competition, we developed a calendar that brought a variety of themes.

I was responsible for the development of the three Silverlight variations of the calendar.

Impressions:

• Date: 2008
• Technologies: C#, Silverlight
• Platform: Browser
• Context: Microsoft Design and Programming Competition "Mathe-im-Advent"

Moppi's World

A small game as a special Christmas gift

This game was a Christmas gift for a friend. It is based on a game called Tamamoppi that she has developed as my birthday gift. Moppis world was originally developed with C# and DirectX. Later I changed it to use XNA 2.0.

The game allows you to toy around with some of these cute Moppis. You can feed them with donuts. They also very happy to play songs with the flute. In addition, you can make them fall in love.

You can download Moppi's World here. The wallpapers for Moppi's world can be found at InterfaceLIFT.

Features:

• Moppis can grow, eat, get fat
• Moppis can play the flute and dance
• Moppis can fall in love and make cute babies
• Various environments
• Everything is configurable (only in the DirectX version)

• Date: 2008
• Technologies: C#, DirectX, XNA
• Platform: Windows XP
• Context: Christmas Gift

Logistics Scenario

A project with multiple teams to realize an integrated logistics scenario

As part of the course "Process Control and Robotics" the DCL infrastructure has been expanded to include a new experiment. It was about the intelligent combination of complex embedded systems to a represent an industrial logistics scenario. To realize this a Lego NXT-based automated warehouse served the Szenrio as raw material storage and as a repository of finished products. These products were delivered by a model railway, which realized the transport infrastructure and "produced" by a Fischertechnik production line system. For the implementation three teams were built, each responsible for one sub-system and an additional integration team, which I was a part of. Our task was to create suitable interfaces and to facilitate the integration of the overall system with the DCL infrastructure.

We also used this project as a case study for our contribution to the course "Management of Complex Projects" creating a sophisticated project management plan based on the task for the logistics scenario.

Features:

Production Line

Robot Arms

Transport

Storage Racks

• Date: 2008
• Technologies: C++, C#, Java
• Platform: Embedded Systems
• Context: Process Control and Robotics

Potato

A Java-based Smalltalk VM

Potato is a Squeak virtual machine completely written in Java. It is a derivative of JSqueak which was developed by Dan Ingalls. Within the the course "Virtual Machine" we heavily refactored it and added a variety of new functionalities.

For a few days, we even had the honor to show our progress to Dan Ingalls and develop together with him.

Meanwhile Potato is published at SourceForge.

Features:

• Load and run larger, modern images
• Calling Java code from within the SqueakVM
• Color and Font support

• Date: 2008
• Technologies: Java, Smalltalk, C++
• Platform: JVM
• Context: Virtual Machines

FTTWP

Fault Tolerant "The Wire Protocol"

The goal of the FTTWP project was to extend the implementation of "The Wire Protocol" (TWP) of the lecture "Middleware and Distributed Systems" with fault tolerance mechanisms. Since TWP was used to teach us the details of CORBA, I decided to study the mechanisms of FTCORBA and apply them on our TWP implementation.

Features:

• Generic Factories
• Replication Manager
• Heartbeat Monitoring
• Error Detection and Notification

• Date: 2008
• Technologies: Java
• Platform: JVM
• Context: Fault Tolerance Seminar

mootJF

A business idea

mootJF is a project that we conceived and developed for the course "IT Entrepreneurship"

The mootJF software system is a web-based platform to support the work of the youth fire fighter brigades in Germany. In this context mootJF is especially tailored to solve the existing problems with communication and coordination that is a consequence of the distribution of the individual groups and facilitate forms-heavy administrative work.

We developed this idea into a solid business plan. Rather than implementing it, though, we devoted ourselves to our studies and greater challenges instead ;)

Features:

• Create and manage member information
• Development of service plans
• Service bookkeeping
• Preparation and analysis of statistics adhering to the standards of the German youth fire fighter brigades
• Organization of courses
• Organization of recreational events
• Communication and knowledge sharing between members of the Young Firefighters

• Date: 2008
• Technologies: tba
• Platform: tba
• Context: IT Entrepreneurship

WizOS @ NXT

A robot operating system

WizOS is a multi-threading operating system for the LEGO NXT robots that we have developed for the course "Embedded Systems".

In addition to the concurrent execution of multiple threads, we developed a task manager that allows you to manage them. Furthermore, a comprehensive library was created to display various graphical objects on the display of the LEGO NXT within the project.

Features:

• Multi-threaded execution of prioritized tasks
• Task manager
• Graphics library to display text and graphics objects

• Date: 2008
• Technologies: C++
• Platform: LEGO NXT
• Context: Embedded Systems

Distributed Control Lab

An online robotics lab

The Distributed Control Lab (DCL) is situated at the Operating Systems and Middleware Research Group at the HPI in Potsdam. It deals with software paradigms and design patterns that allow an interconnection of middleware-based components and embedded mobile systems. The primary point of interest is how to reach a predictable system behaviour (regarding to timing behaviour, fault tolerance or resource usage) in an unstable environment. The evaluation of the different approaches is done with the help of case studies, one example is a web-based control of mobile robots in the lab.

As part of my bachelor project, my project team and I created the new DCL based on the coordination layer of Adaptive Service Grid (ASG). The Coordination Layer provides functionality for load balancing and fault tolerance. We used this functionality by creating web services for each experiment.

In the following years I was responsible for the maintenance and expansion of the DCL infrastructure and the various experiments.

Selected Experiments:

Foucault's Pendulum

High Striker

Fischertechnik

LEGO Robots

Märklin Trains

Robot Simulator

Features:

• Webfrontends with ASP.NET, Silverlight, ...
• Java-core provided via WebServices
• Java and C# Execution Environments for the student code
• Robots can be programmed in C/C++, Java, C#
• Seperation of code compilation and execution
• Dynamic Experiment placement
• Experiment protection with sandboxing and safety controllers

• Date: 2006-2009
• Technologies: C++, C#, Java
• Platform: Multiplatform
• Context: Online Robotics Lab

Puckman

A team project for a Pacman clone

Puckman was our project in the Game Design Seminar. The goal of the project was to create a Pacman clone in 2.5D.

The name was chosen based on the original, first Pacman. This was released in Japan under the name "Puck Man". The "Puck" here is derived from the Japanese word "paku paku" which means something like "nom nom".

Features:

• Jumping Puckman
• Various themes (Standard, Halloween, Matrix and X-Mas)
• Varying intelligence levels of the ghosts
• Bonus for more dangerous items
• Transparency, shadows
• Animated menu
• 20 Levels

• Date: 2007
• Technologies: C++, OpenGL, VRS, FMOD
• Platform: Windows XP
• Context: Game Design

Intrusion Tool

A team project for security

As part of the course "Internet Security" we have created a system for remotely controlling and spying on other PCs in order to better understand the basic workings of similar applications.

The Intrusion Tool is the component of our system which is placed on the attacked target system. Here it waits for commands from the Intrusion Tool Controller and executes them on the target system. To make it easy to expand and adapt the system for new applications, we have ensured that programmers are supported by the infrastructure when adding new types of resources and new commands. The Intrusion Tool is implemented in C ++.

The Intrusion Tool Controller provides a simple way to manage the Intrusion Tool. It provides a user-friendly query language and converts the entered commands into commands the Intrusion Tool can process, pays attention to the correct specification of parameters and provides a forwarding functionality. The Intrusion Tool Controller is implemented in C# and requires the .NET Framework version 2.0.

Before the Intrusion Tool can be used, it must be placed on the attacked target system. A good way to do this is by using the Metasploit Framework.

Features:

• Remote Control to other computers
• File system access, Registry access
• Starting, stopping and listing processes
• Easily extensible

• Date: 2007
• Technologies: C++, C#
• Platform: Windows NT
• Context: Internet Security

Distributed Computing Framework

A team project for interoperability

DisCo was our project for the course "Component Programming and Middleware" (hence the name "Distributed Computing").

The system consists of a server that maintains a list of work packages and several clients who execute these task. A work package can contain any Java code; Sandbox mechanisms on the client side help to create security and stablety for incorrect or malicious programs.

To make the whole thing a little more interesting, we have decided to implement the server using the .NET Framework, the management frontend for the server with C++ and the client with Java. Communication was realized using CORBA.

Particularly important for us was also to learn and apply design patterns. We used the following patterns: Dependency Injection, Facade, Adapter, Proxy, Mediator and Observer.

Features:

• Framework to distribute and execute arbitrary Java tasks
• Sandbox-mechanism
• Three programming languages involved
• CORBA-based communication

• Date: 2006
• Technologies: Java, IIOP.NET, C++, CORBA
• Platform: Windows XP, Linux
• Context: Components and Middleware

Mazda Racer

My first fully functional computer game

Mazda Racer was my final project for the computer science classes at Gymnasium (school). It was developed using Visual Basic and Managed DirectX 9.0.

It allows you to drive a tiny Mazda car. The goal is to complete the course as fast as possible without colliding with walls or other objects from the game world (which would slow you down). For the engine sounds, we have recorded an genuine Mazda 323f :)

Features:

• Level Editor
• Multiplayer Mode for up to 8 Players
• Customizable your Mazda's looks
• Choose form a variety of horn sounds

• Date: 2004
• Technologies: Visual Basic, DirectX 9.0
• Platform: Windows 98
• Context: School project