Oliver Schoenborn

Designed and implemented delivery pipelines using Spinnaker, Python, and Docker. Automated provisioning of a Kubernetes cluster in AWS EC2 using kops and Python and Docker maintenance and QA of Helm charts.

Integrated C# .NET 4 (managed code on Windows) with Visual C++ 2005 (unmanaged) and Lua 5.1 to provide a 2+1D virtual environment where student could learn to troubleshoot modern integrated avionics.

The C# layer provided the GUI and UX, including imagery, guidance, navigation in the 2D environment, use of diagnostics tools by trainee, and realistic "live" cockpit instruments. The unmanaged C++ layer provided the business logic, from configuration, startup, and navigation in 2D environment to simulation of avionics including databus, progression tracking, and instrument failures. The Lua layer provided the scriptability of the application, including definition of instrument pages used interface with health-monitoring system (HMS), configuration of scenario components and capabilities, and configuration of goals/progression.

The application was multi-threaded, with the C++ layer acting as a service available to the GUI, and scripting allowing for extension and scenario definition without recompilation. Very powerful and very stable.

Led the development of a fully immersive crane simulator. I was in charge of requirements management, system architecture, core components such as scenario definition, multi-computer multi-process data exchange C++ infrastructure, and hardware emulation using Java. As lead engineer, I was in charge of interface design and integration of components developed by other team members such as sound generation, crane physics, crane hardware, and immersive projection system with motion tracking and active 3D glasses. The system consisted of multiple computers exchanging data over TCP/IP, UDP, and shared memory, and an XML-based configuration system. The system was featured on the Discovery channel.

PubSub is a Python publish-subscribe engine for applications that are event-based. Originally developed as part of wxPython, I took over this project in 2003 based on some significant improvements and extensive automated unit testing that I created for it.

Lua-icxx is a helper library to facilitate embedding Lua in a C++ application via an OO API so that the Lua stack can be completely invisible. It integrates with SWIG to make SWIG-based Lua wrappers available to C++ applications; without this, a developer is forced to use Lua's very low-level C API.

In this one project, I decided to upgrade the test harness from Python nose to PyTest due to some significant gains in test robustness that could be achieved with the latter. Since there were thousands of tests, this could not be done manually. I wrote a converter based on Python's bulit-in pattern matcher for its abstract syntax tree, and added it to GitHub and submitted it to the PyTest project, to which it was accepted.

IOF is a formatted input/output library to provide printf/scanf-like format-string-based I/O with C++ streams. Similar to Boost's format module, but compact (esp. compared to Boost), without any external dependencies. Also, it does not require any build (it is purely C++ templates).

Integrated managed C# 2010, unmanaged C++ 2005, and Lua into one application. It may be difficult to appreciate the challenge until you try. Part of the challenge may have originated in the C++ layer which was a third-party library. Additionally, the C++ portion was in a separate thread, and had to be accessible from the Lua portion. I finally managed to make everything work into a robust and high-performance system.

Developed a sophisticated GUI supporting an extensive set of user actions managed via a state machine to limit actions available at any given time to a very small subset of all available actions. Developed a fully automated testing system for memory leaks, performance, and behavior of this application, based on PyUnit, Jenkins, and mocks. Designed the installation system, the documentation, and the multi-core engine enabling the simultaneous execution of business logic on a large number of cores to increase performance 1000-fold.

This project consisted of a Python GUI written using PyQt, and allowed the user to define Python scripts to be executed by the application. Add debugging capabilities to set and hit breakpoints in the scripts, stepping through script code, getting local variable values, etc. The documentation was poor and, eventually, I figured out how to make this work without blocking the GUI!

Using DOORS, Python, PyQt (Python wrapper for the Qt library) and SQLite, I designed and developed a GUI and a console application that supports defining a business process and executing it to do what-if analysis using parallel Monte Carlo simulations of 10,000 replications distributed over as many cores as are available on the computer (48, 128, etc.). I automated the testing of the application using PyTest, Jenkins, and mocks.