Elementary School

1997-2004

Gymnasium (high school)

2004-2009

Software Engineer

Kaupisch ITC SolutionDesign, development and quality assurance of standard software for small and medium-sized enterprises with C#, LINQ, WPF, SQL, WindowsForms.

2004-2007

Bachelor Studies

IT Systems Engineering at the Hasso Plattner Institute Potsdam, GermanyBachelor of Science in 2007Main topics: Sofware Architecture, Internet TechnologiesThesis: "Development of a transnational experiment-based learning environment in the Leonardo da Vinci program of the European Union"

2006-2009

Software Architect

I was responsible for planning, developing and maintaining the software infrastructure of the Distributed Control Lab, our lab for software-controlled physical experiments. C#, ASP.NET, Java, Web Services, C/C++, SQL

2009-2012

International collaboration with the Hasso Plattner Center for Scalable Computing at the Technion – Israel Institute of Technology in Haifa, Isarel; the HPI Research School for Mass Data Analytics and Knowledge Discovery at the Nanjing University in China and the Hasso Plattner Institute in Computer Science for Africa in Cape Town, South AfricaResearch focus on parallel programming models, esp. approaches to handle the complexity of hybrid parallel architectures w.r.t. coding experience and resulting application performance.OpenCL, CUDA, parallelization, optimization

The advent of homogeneous many-core processors has been widely noticed as a major shift in the architecture of commodity computer systems. It has influenced the design of operating systems and programming models and gives a boost to high-level parallelization libraries. Future commodity systems will combine homogeneous many-core processors with graphical processing units and other special purpose accelerators to a new class of architecture called hybrid system. These systems provide improved hardware support for specialized computational tasks of different applications. In contrast to the programming for homogeneous architectures with existing tools, programming for such hybrid architectures is still in its infancy. Today, the software development for such systems explicitly has to address vendor-specific and version-specific characteristics of the particular devices. Due to this, refactoring of existing code becomes a tedious and error-prone task. We present our approach for automatically transforming high-level parallel code written in .NET to parallel code suitable for direct execution on hybrid systems. Our approach relies on the transformation of .NET byte code to an accelerator-aware version, which makes the concept applicable to all .NET-supported programming languages. Hybrid system hardware is targeted by the generation of accelerator-neutral intermediate code, which makes our approach applicable for a wider class of accelerator types. We show the feasibility of our solution with a workload that consists of well-known and widely accepted compute-intense algorithmic problems.

Using graphics hardware to enhance CPU-based standard desktop applications is a question not only of programming models but also of critical optimizations that are required to achieve true performance improvements

With the ongoing internationalization of virtuallaboratories, the integration aspect becomes moreimportant. The meanwhile commonly accepted ’glue’ forsuch legacy systems are service oriented architectures, basedon standardized and accepted Web service standards.We present our concept of the ’experiment as a service’,where the idea of service-based architectures is applied tovirtual remote laboratories. In our laboratory middleware,experiments are represented as stateful serviceimplementations and jobs as logical service instances ofthese implementations. We discuss performance, reliability,security and monitoring issues in this approach, and showhow the resulting infrastructure - the Distributed ControlLab - is applied in the European VetTrend project.

Todays commercial off-the-shelf computer systems are multicore computing systems as a combination of CPU, graphic processor (GPU) and custom devices. In comparison with CPU cores, graphic cards are capable to execute hundreds up to thousands compute units in parallel. To benefit from these GPU computing resources, applications have to be parallelized and adapted to the target architecture. In this paper we show our experience in applying the NQueens puzzle solution on GPUs using Nvidia's CUDA (Compute Unified Device Architecture) technology. Using the example of memory usage and memory access, we demonstrate that optimizations of CUDA programs may have contrary results on different CUDA architectures. Evaluation results will point out, that it is not sufficient to use new programming languages or compilers to achieve best results with emerging graphic card computing.

Remote and virtual laboratories are commonly used in electronic engineering and computer science to provide hands-on experience for students. Web services have lately emerged as a standardized interfaces to remote laboratory experiments and simulators. One drawback of direct Web service interfaces to experiments is that the connected hardware could be damaged due to missed deadlines of the remotely executed control applications.
Within this paper, we suggest an architecture for predictable and interactive control of remote laboratory experiments accessed over Web service protocols. We present this concept as an extension of our existing Distributed Control Lab infrastructure. Using our architecture, students can conduct complex control experiments on physical experiments remotely without harming hardware installations.

State-of-the-art computer systems are a combination of general purpose processors and special function accelerators. The most common type of accelerators are GPU compute devices, which are used for some years to compute a variety of data
parallel tasks fast and energy efficient. Since the release of Intel’s Sandy Bridge architecture and AMD’s APU technology graphic compute units are integrated into each new processor. Despite their wide availability only a relatively small amount of projects makes extensive use of these hybrid systems. That applies in particular to projects that are realized in standard languages like Java. One main reason for this is the fact that it is laborious to learn to use the software libraries for hybrid architectures and that a deep understanding of the characteristics of the underlying hardware is often necessary, as well. The burden of that this creates is often too much for small and mid-sized enterprises and project teams.
In this paper we show a way to allow such projects to get access to the hidden performance of hybrid systems while keeping the effort to learn new language constructs as low as possible. Our solution supports the development of new software projects as well as the refactoring of existing software systems.

Computer architecture is shifting. The upper levels of the software stack are thus to be adapted in order to benefit from the current and future hardware capabilities. In this paper, we present the Hybrid.Parallel library. It is our approach to bridge the gap between state-of-the-art computer architecture and application developers (in contrast to performance engineers, tuning experts, ...) In order to exploit the full computing power of a system, all execution devices have to be identified and used. Tasks and data have to be distributed according to the specific features of the devices and the overall system. We present our analysis of tasks and data in the shared memory parallel domain and propose mappings onto execution units and memory types. Furthermore we discuss language constructs that allow developers to adjust these mappings to their needs. These findings provide the basis for the implementation of the scheduler for our Hybrid.Parallel library and may also be applied to the Single-Chip-Cloud-Computer.

Many of the computational problems we are facing today are complex and need huge computational power to be solved. It is well-known that processors will not continue to get faster, but will get more cores instead. More cores are not only harder to utilize by an application programmer, but also challenge hardware designers. Thus various new hardware architectures are designed and evaluated in order to find the ones that will fulfill the needs of future computer systems. Prototypic configuration boards like Intels Single Chip Cloud Computer (SCC) are an attempt to deal with the ever-increasing number of cores by removing essential features of current processors like hardware cache coherency. Another approach is to accompany common general purpose CPUs with sophisticated special purpose processing units. These so called Accelerators are easier to build and very fast for specific application purposes. They are the foundation for the new trend of hybrid computer systems.

Since services are hosted by application servers, shifts in the underlying systems have a great influence on their efficiency and functionality. Therefore it is necessary to get a deep understanding of trends in operating systems and middleware as well as hardware environments. This paper discusses some of these shifts. It will take a short look on energy efficiency and a deeper one on programming models for multicore computers. Thereby first the application of graphic cards for parallel computing will be evaluated using the example of CUDA. Then a brief summary on the limits of threads for the Windows platform is shown.

Within the bachelor project ”DNA“ the Distributed Control Lab (DCL), that facilitates the usage of real-time control experiments, and the ASG-C5 component of the Adaptive Services Grid (ASG) for dynamic placement of services, were combined.
Thereby, the ASG-C5 component was reimplemented. Besides, a scheduling mechanism and a component that augments the WSDL of a service with state management methods was created. The new system is able to interoperate with execution environments for miscellaneous programming languages. An execution environment for .NET web services was realized. Furthermore, the data management was optimized for heterogeneous usage. In addition to the portation of existing DCL experiments, tools for the creation of new services were added. Also, the existing management interface was reimplemented and extended by algorithms for the analysis of measurement data.
The user interface was extended and revised in order to provide better usability for the experiments in the new system. The developed system allows the distributed usage of experiments or web services, that can be provided in miscellaneous programming languages. Within the VET-TREND project the new lab infrastructure will be available
to different partners throughout Europe.

Enterprise applications are becoming increasingly complex. To meet the high demands that are put on them you need sophisticated technologies that support the development of enterprise software and provide a platform to deploy programs in a scalable, flexible and secure environment. Such an environment is provided by the application server for the Java ™ Platform, Enterprise Edition. Standard benchmarks like the SPECjAppServer2004 benchmark are used as a decision aid which server fits best for a specific scenario. These benchmarks are representative for a widespread business scenario and evaluate the application server in terms of their performance in this. Although the importance of open source software is unbroken, there are currently no comparisons of the two popular application server JBoss and Glassfish using the SPECjAppServer2004 standard benchmark. This work fills this gap by investigating the JBoss and Glassfish application server in terms of their performance and their use of resources with the help of the SPECjAppServer2004 benchmark. Doing this, it provides an important contribution to the comparability of the two application server. It contains an overview of evaluation tools, a description of the SPECjAppServer2004 benchmark and related work. The main part of the paper is devoted to the evaluation of the Glassfish and JBoss application server and the comparison of their results. Finally, it contains an outlook on further topics and open questions.

Hybrid systems built of general purpose processors and special purpose accelerators, such as GPUs, are the next challenge for large-scale parallel processing. While CPU-oriented software development can rely on high-level programming models, the world of accelerators looks immature. Programming these devices currently requires a deep understanding of the underlying hardware structuring, in order to achieve correctness and performance. This talk introduces our work on high-level programming models and novel applications for heterogeneous parallel computer systems. We will discuss the different system layers affected by the paradigm shift, and show examples for a better exploitation of the new combined hardware capabilities.

2011

Hybrid systems built of general purpose processors and special purpose accelerators, such as GPUs, are the next challenge for large-scale parallel processing. While CPU-oriented software development can rely on high-level programming models, the world of accelerators looks immature. Programming these devices currently requires a deep understanding of the underlying hardware structuring, in order to achieve correctness and performance.
This talk introduces our work on high-level programming models and novel applications for heterogeneous parallel computer systems. We will discuss the different system layers affected by the paradigm shift, and show examples for a better exploitation of the new combined hardware capabilities.

Hybrid systems built of general purpose processors and special purpose accelerators are a promising way to deal with massive multi-core. Even today they help to speed-up a variety of applications from several domains. Programming these devices, though, still requires a deep understanding of the underlying hardware.
We present a proof-of-concept implementation of a general purpose library for the .NET Framework that abstracts from the hardware characteristics and allows developers to program OpenCL-enabled accelerators using their favorite high-level-language.

Besides the many cores of their CPUs, future computing systems will utilize additional processing units, such as GPU, krypto coprocessors, etc. Dynamic voltage and frequency scaling will lead to non-uniform behavior even among homogeneous compute units. Due to high integration density, probability of faulty system behavior will increase dramatically.
The talk will outline those challenges and present our research to tackle above-mentioned problems. We will present the hybrid.parallel project, an approach to transparently address CPU and GPU compute units from the same source base. Our cooperating hypervisor project on the Intel SCC addresses the question of how to manage memory hierarchies on future reconfigurable manycore systems. Finally, we will discuss how to apply multilevel fault prediction and proactive migration of virtual machines in order to deal with arbitrary faults in multicore hardware. Our research is being carried out within the FutureSOC lab @ HPI, a testbed infrastructure with prototype hardware that is supported by vendors such as Fujitsu, Hewlett-Packard, EMC, VMware, SAP.

Hybrid systems built of general purpose processors and special purpose accelerators are a promising way to deal with massive multi-core. Even today they help to speed-up a variety of applications from several domains. Programming these devices, though, still requires a deep understanding of the underlying hardware.
We present a proof-of-concept implementation of a general purpose library for the .NET Framework that abstracts from the hardware characteristics and allows developers to program OpenCL-enabled accelerators using their favorite high-level-language.

2008

Connect With Me

Want to get in contact? Choose your platform! ;)

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.

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.

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.

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.

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.

Impressions:

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. ;)

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.

Rorschach Android App

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.

Impressions:

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.

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.

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.

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.

Features:

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:

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 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:

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.

Features:

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.

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".

Intrusion Tool

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 :)