Projects
Here you can find some of the projects I have been working on for university, work, or fun. You can find the code for most projects on my GitHub.
I co-created and maintain Lively4, a live, self-sustaining, and wiki-like web-based programming environment and application platform. Lively4 integrates the spirit of Squeak/Smalltalk with modern Web technologies. It allows you to modify applications while they are running and can be loaded into external Websites to script them. We use Lively4 as a vehicle for personal, research, and teaching projects.
A JavaScript implementation of Vivide, a graphical tool building framework. Vivide supports working with live data in a tangible manner and the effective scripting of visualizations using an expressive DSL.
An interactive visualization to explore massive hierarchical data structures with relations like software projects with dependencies. Edge bundling provides high-level insights while the interactions allow you to focus on specific parts of your dataset.
I created floom, a fluid simulation written in JavaScript. floom uses the Material Point Method, a hybrid variant of particle and grid systems. You can switch to computational models and change material parameters on the fly.
The X-Ray is a graphical tool that overlays over the user interface of a website. It allows developers to reveal and inspect the internal structure of the DOM hierarchy and makes user events visible.
An Active Expression-based implementation of Signals, a reactive data type that allows to model functional data dependencies in a program. This implementation works similar to conventional Signals but updates on every state change, not just on Signals.
I developed Active Expressions, a reactive primitive that adds reactivity as a first-class citizen to state-of-the-art languages such as JavaScript, Python, or Smalltalk. You can define an object-oriented expression and get notified whenever any state change affects the expression's result, triggering your callbacks. Based on this mechanism, you can easily write more involved reactive programming concepts. Available in multiple implementation variants including byte code rewriting, dynamic interpretation, and using proxy objects.
In Context-oriented Programming, one dynamically activates behavior variations of a program for some duration. Zone-based Layer Activation is a variant of dynamic extent that activates variations for the duration of a block, including all its logically-connected asynchronous operations such as Promises and native async/await. Implemented in ContextJS in JavaScript using customized zones.
I am one maintainer of ContextJS, the goto JavaScript implementation of Context-oriented Programming. ContextJS allows to define behavior variations that activate dynamically at runtime and cross-cut inheritance-based modules.
A variant of implicit layer activation that enables adaptations to system behavior while a declarative Boolean condition holds. Using reactive programming, we eagerly (de)activate variations, allowing them to be combined with life-cycle callbacks.
I created a custom editor for board and trading card games. The editor is directed towards quick iteration through minimizing time to create a playable prototype to gather feedback. This includes layouting, card art, and simplifying printing.
A personal knowledge graph and surrounding tooling with the idea to make your everyday data (eMails, todos, contacts) tangible and programmable. As an antithesis to the app concept, you work directly with objects from different domains, associate them, and create or customize your workflows according to your specific needs. Powered by an underlying ontology described as triples.
Together with Markus Brand, I developed a toolset that allows programmers to inspect and debug multiple reactive programming concepts that interact and collaborate in a single system. We designed tools to investigate their cross-cutting aspects, including over-time structure, evolution of values and events, and the relation of dynamic information and static source code.
Babylonian Programming scales example-based live programming toward big software projects. You create examples for classes and functions. Example executions augment static source code with live data inlined using probes. In Lively4, we developed the original implementation of Babylonian Programming.
Our entry for the 6th HPI GameJam on Alternative Input Methods. Each level, you preprogram your little blobby avatar's action like running, jumping, digging, or gravity-reversing. Then, time these actions using only a single button, or banana.
In our bachelor's project we developed massive data visualizations for the Web. We created a graph visualization framework to explore software analysis data both on desktop or inside a browser.
Reactive Object Queries allow developers to query objects that satisfy a condition, regardless of their position in the program's object graph. The created view updates live as program state changes and can be further transformed or augmented with additional behavior.
Pronto is a game mechanics prototyping tool build on top of the Godot game engine. It encourages quick assembly and rapid iteration. To do so, Pronto makes behavior tangible as visible objects in the game scene. Visual drag-and-drop connectors overlay the scene to define trigger-action relationships. I worked primarily on Pronto's conceptualization and initial version.
Bloob is a full-fledged physics engine for soft-bodies written in JavaScript. It features spring- and pressure-based soft-bodies, different types of forces and joints, dynamic object creation and manipulation and built-in debug rendering.
Together with Eva Krebs, I built Lively4's version of connectors. Connectors allow you to mash-up widgets using graphical dataflow connectors to quickly assemble applications. Connectors can listen to any property, event, or expression on the source widget. Created connections can be persisted, bundled to bigger applications, and shared with others.
The Plugin Explorer is an editor specifically designed to develop compiler extensions, here babel.js plugins. The editor provides linked views on the textual and abstract syntax tree representations of both example input and computed result. Due to its live programming properties, the editor allows you to instantly review the effects of your changes by comparing input and result with the intended behavior. Changes to the compiler apply immediately to the Lively4 environment, so you can use new capabilities right away.
Together with Tom Braun, I developed a back-in-time debugger for our compiler editor. Using it, you can view the entire execution trace of a compiler and easily identify, which control pathes it took and how the program was modified.
GrindScript is a prototypical visual programming language to program units' artificial intelligence. It emphazises input efficiency and intuitiveness over discoverability.
Babelsberg is an Object Constraint Programming Language, allowing you to specify invariant using object-oriented expressions. These invariants are automatically maintained by a set of constraint solvers. I worked on parts of Babelsberg/JS and extended it with scoped constraints and a configurable reactive constraint solver.
Together with Luc Prestin and Eva Krebs, I designed the educational board game Some Educational Board Game to fill a gap in a software engineering lecture that lectures and an accompaning student project could not cover. We use the game as an engaging introductory activity to convey core values of agile processes. I oversaw the design process of the game, providing design feedback.