Jens Stimpfle

I'm working on a client-server architecture and GUI App that runs on Linux and Windows. It allows the definition of "skeletal" machines for industrial applications. The machines are composed of moving parts composed into a hierarchy (linear and rotational movements are supported). The GUI App needs to subscribe to the server and allow the streaming of axis data over the network. It needs to update the 3D view in real-time. There is also some light interactive editing of the skeletal configurations.

The app is written from the ground up with minimal dependencies: LibC, OpenGL, and platform APIs (Linux/Windows - for file access, networking, and window context creation). It also includes a small custom written GUI widget toolkit.

(Contracted work; no further details can be shared).

Server software written in C for a medical device that exposes data read in real time from many sensors and an FPGA mapped to physical memory. Some low-latency architecture work is involved since the FPGA has only 8ms worth of buffer (an unfortunate setting), and the data needs to be continuously streamed out over the network to subscribed clients. (This is a contracted project; no further details can be shared.)

I'm building a jigsaw puzzle game that runs on Linux and Windows. It is designed to efficiently handle many pieces (more than 1,000) that are rendered in real time. The pieces can be "designed" in-game using Bezier curves and a simple triangulation algorithm. They are initially created by adding some randomness to default shapes. The pieces can be rotated in all four orientations, with smooth in-betweens for animation. There are free zooming and grouping to improve ergonomics. I'm currently working on low-latency networking for an excellent cooperative multiplayer experience.

The game also features a minimalistic Widget UI to build the menus. There are no dependencies except OpenGL and platform APIs—Win32, X11, and libc for file access, window context creation, and networking.

I'm building a high-performance, ultra-low latency text editor that can edit even huge files (gigabytes) without breaking a sweat. It typically takes on the range of 5 to 30 microseconds for editing operations to complete even for huge files, leaving plenty of headroom for advanced operations like syntax highlighting and other IDE features which I'm currently working on (for interactivity typically a few milliseconds are available before the user can notice).

Also, the memory overhead is low - about 5% of the size of the edited text.

The performance and efficiency are achieved through the implementation of a custom Red-Black Tree and a Textrope data structure, which is a nontrivial engineering effort. These are already performing as advertised, although I might make further improvements to support particular requirements.

I'm working on a programming language (including a compiler) for systems-level programming. The language is designed to be as minimal as C but to have a cleaner syntax, to include a few tiny features missing from C, and to offer much faster compile times. The compiler is developed in C with no dependencies except for reading and writing files.

This is a little project that manages git repositories for groups of developers. User and authorization data is stored in an SQLite3 database. Users can create new projects and give permission to other users. A very lightweight alternative to Gitlab, similar to Gitolite.

I've spent considerable time on algorithmic programming platforms like SPOJ.com and HackerRank.com and developed a good feeling for asymptotic complexity and constant-factor optimizations. I invented some nifty ad-hoc tricks, like replacing a hash map by a low number of stacks in graph searches with integer costs and good locality, to drastically improve performance with very low overhead in code complexity.

I created a desktop application that periodically downloads RSS feeds from the network and displays them in a newsticker. I employed OpenGL for good visual quality. It was only partly a success because bitmaps turned out not an optimal choice for scrolling on common resolutions (~100dpi). I have since learned more about graphics programming and plan to write my own vector font rendering shaders.

I've spent some time designing a plain text format for relational databases (and also a Python library for reading and writing). WSL competes against the widespread CSV and tries to improve on canonical data representation and low-noise lexical syntax. The problems I've encountered: It's very hard to come up with meaningful, canonical, universal data types. Focusing on practicality I didn't want to push in the direction of abstract syntax notations (very complex). On the other hand, providing the database schema beforehand turned out to be a very good idea, because it enables a much cleaner and unambiguous syntax.

I developed a Tetris game based on plain HTML, CSS, and JavaScript (rendering with styled DOM elements).

The challenge was to do this in < 3 hours, on a plane without internet access (and crammed in a way too small seat). I'd never done a Tetris game before and wanted to prove to myself that I'm able to focus on results and get things done quickly.

This is a project where I learn about the OpenGL API and Game Engine related topics, such as 3d math, Polygon meshes, serialization, network, evens systems, and generally simple non-OO data structure design.

This is my first attempt at implementing a parser and data structures for a C-like language. I've explored avoiding creation of an AST, which is a lot of boilerplate, and that worked beautifully. In the meantime I've improved on these ideas, and created a more complete Pascal parser (not public code).