This page contains a list of many of my software development activities, professional and private alike. My contributions include software packages for different subject areas, e.g., linear algebra (LAPACK), machine learning (Caffe2), blockchain (go-perun), and package managers (Spack); software development, build management, and testing.
To discover my work, I suggest to have a look at my GitHub comments for my most recent activities in free and open source software (FOSS), the table below for my larger software development projects (FOSS and closed source), or the time-line of all of my projects after these tables.
Last update: January 30, 2022
| Project | Date | Activity |
|---|---|---|
| Melissa CI | Since September 2020 | Virtual Machines and Containers for Melissa Continuous Integration; project founder and main developer (as Inria employee) |
| Melissa | Since August 2020 | Melissa: Modular External Library for In-Situ Statistical Analysis; main developer (as Inria employee) |
| LAPACK | Since April 2020 | A new GSVD solver; my contributions are design and implementation of the pre-processing phase and the first numerically stable implementation of a GSVD based on the CS decomposition. |
| go-perun | August 2019 to February 2020 | Perun's Blockchain-Agnostic State Channels Framework in Go (as TUD employee) |
| Rademacher Floating-Point Library | February 2019 to March 2019 | The first algorithm computing all uniformly distributed floating-point numbers in any interval |
| Fluent.ai ASR for microcontrollers | August 2018 to January 2019 | Ported Fluent.ai's acoustic speech recognition system to a microcontroller (as Fluent.ai contractor) |
| deepstream.io C++ client library | December 2016 to February 2017 | A C++ client for the deepstream.io protocol (as DeepstreamHub contractor) |
| DCGeig | December 2015 to December 2016 | The divide-and-conquer generalized eigensolver for large-scale eigenvalue computation for my master's thesis |
| Large-Scale Eigensolver | January 2013 - May 2015 | Solver for Adaptive numerical solution of eigenvalue problems arising from finite element models. AMLS vs. AFEM |
Most of my FOSS contributions can be found on GitHub. The ones that cannot are in the following table.
| Project | Date | Activity |
|---|---|---|
| GMP-ECM | 2020-10-09 | Prepared moving from Gforge to GitLab: GMP-ECM repository moved to gitlab (as Inria employee) |
| GNU ld | 2018-10-25 | [Patch][ld] ELF: update ld man page on `--gc-sections` (as Fluent.ai contractor) |
| GNU ld | 2018-10-18 | Useless `DT_NEEDED` tags after Garbage Collection (as Fluent.ai contractor) |
| LAPACK | 2015-10-06 | Bug 139: xSTEDC eigenvalues not sorted |
Project Details
Melissa CI (Continuous Integration)
The software Melissa (see below) is expected to run on personal computers and TOP500 supercomputers; these machines run on different Linux distributions, different instruction set architectures, and with different batch schedulers (e.g., Slurm or OAR). Melissa CI contains scripts for creating containers imitating these environments. The containers are hosted on a x86-64 computer and a Raspberry Pi 4 (aarch64); they are used by multiple projects whenever commits are pushed to git repositories. The project was devised and implemented by me including build scripts and the code enabling gitlab-runner to use LXC. Hardly any maintenance is required and only a small upfront investment (the x86-64 host was previously unused, only the Raspberry Pi and a fast USB flash drive had to be bought).
Technologies and Skills used
- Continuous integration, automated testing, system administration
- Python3, bash
- Docker, Linux Containers (LXC)
- Alpine Linux, CentOS, Devuan, Debian, Rocky Linux
- gitlab-runner
Project duration Since September 2020
Melissa
Melissa (Modular External Library for In-Situ Statistical Analysis) is a software package for large-scale in-transit (in-situ) statistical analysis of scientific data (e.g., grid information in finite element simulations). The software must work on personal computers as well as TOP500 supercomputers on any instruction set architecture (e.g., x86-64, aarch64, and POWERV9). As a maintainer, proposing and enforcing software development best practices is also one of my responsibilities.
Technologies and Skills used
- Statistics, numerical analysis, software portability, automated testing, continuous integration
- C99, Python3 (for Python 3.5+)
- CMake
- MPI, Slurm, OAR
- TCP, Infiniband
Project duration Since August 2020
go-perun
Current popular blockchains easily reach their transaction limits. go-perun is an implementation of the Perun Layer 1 state channel protocol for blockchains. This provably secure protocol transparently removes the limits on the number of transactions that can be processed by blockchains and enables transactions between different blockchains.
go-perun is highly concurrent and my major contribution was testing for concurrency bugs not detected by the golang race detector.
Technologies and Skills used
- Cryptography, blockchain, concurrent programming, automated testing
- golang
Project Duration
January 2019 - February 2019
Rademacher Floating Point Library
Surprisingly, as of 2018 there was no software available computing random uniformly distributed floating-point numbers. The Rademacher Floating Point Library (RFPL) provides a C++11 class computing random uniformly distributed floating-point values in a given half-open interval [a,b). In comparison to every other existing software, this library
- draws randomly from all floating-point values in range,
- computes values that are actually uniformly distributed,
- avoids round-off errors causing out-of-range values,
- uses only integer arithmetic, and
- works with built-in C++ float types as well with custom floating-point types.
RFPL is licensed under the Mozilla Public License 2.0 and therefore free software ("free" as in "free beer" as well as "free" as in "freedom").
Technologies and Skills used
- Numerical analysis, IEEE floating-point arithmetic, complexity theory, automated testing
- C++11, Bash
- GCC, Clang, libstdc++, libc++, Catch 2, CMake, git
Project Duration
January 2019 - February 2019
Porting Fluent.ai's Wake Word Recognition System to an Embedded System
I single-handedly ported Fluent.ai's wake word recognition system to Arm Cortex-M processors with floating-point unit. One of the deliverables used an existing speech model with four wake words and ran it unaltered at 60 MHz with power consumption in the microwatts range. I did not create the machine learning models for Cortex-M.
Technologies and Skills used
- Numerical analysis, digital signal processing, real-time computing, embedded software programming, algorithmic optimization, automated testing
- C++11
- GNU Arm Embedded Toolchain, Catch 2, CMake, git
Project Duration
July 2018 - January 2019
Build System Ownership at Fluent.ai
My main responsibility at Fluent.ai was building Fluent.ai's software and its dependencies for development and deployment for current computer architectures including personal computers, the Raspberry Pi, and a wide range of mobile devices.
Technologies used
- C++, C, Python, Bash
- GCC, Clang, CMake, GNU Make, git
- Linux, Android, iOS
- x86, x86-64, ARMv7, ARMv8 (aarch64)
Project Duration
March 2017 - April 2018
deepstream.io C++ Client
deepstream.io C++ Client git repository at GitLab
deepstream.io C++ Client git repository at GitHub
Originally hired as a tech writer, I was solely responsible for the initial deepstream.io C++11 client implementation including WebSockets connectivity, message serialization, message deserialization, and handling of deepstream event as well as user presence capabilities. The client was tested on OS X, Amazon Linux AMI, Raspbian (ARMv7 CPU), and with Travis CI.
Technologies used
C++11, GCC, Clang, Clang static analyzer, Flex, Poco C++ libraries, Boost.Test, Travis CI, Valgrind, American Fuzzy Lop, git, CMake
Project Duration
December 2016 - February 2017
DCGeig
Eigenvalues and their eigenvectors are important tools for analysis in many disciplinces. For example in structural mechanics, eigenvalues and eigenvectors (called eigenfrequencies and eigenmodes) enable the analysis of free vibrations, they can be used for modal superposition, and they are helpful in studying noise, vibration, and harshness (NVH). DCGeig is a solver for large, sparse generalized eigenvalue problems 
arising, e.g., from finite element analyses of elliptic PDEs or time-discrete hyperbolic PDEs. It computes the smallest eigenvalues and it is especially well-suited if a large number of them is needed. Moreover, DCGeig is a black-box solver meaning it requires only the matrices and the maximum desired eigenvalue for proper operation.
DCGeig is a further advancement of the sparse eigensolver in my master's thesis. Numerical stability was improved further, parallelism was increased, and convergence improved by means of Chebychev polynomials.
Technologies used
Python 2, Python unittest, NumPy, SciPy, Cython, METIS, git, CMake
Project Duration
Apr 2016 - January 2017
Eigensolvers for generalized eigenvalue problems with Hermitian Positive Semi-Definite Matrices
Based on LAPACK, I implemented three solvers for dense problems for my master's thesis:
- a solver deflating infinite eigenvalues before calling the LAPACK standard solver,
- a GSVD-based solver computing the GSVD directly with LAPACK, and
- a GSVD-based solver computing the GSVD by means of QR factorizations and the CS decomposition.
The solvers were written once in C++ with templates so that single and double precision implementations were generated by the compiler. The code was tested in Python. The foreign function interface was done with "extern C" declarations in C++, C headers, and Cython.
The dense solvers were later used in a solver for large, sparse generalized eigenvalue problems with Hermitian positive definite matrices. This work was also part of my master's thesis.
Technologies Used
C99, C++11, Python 2, Boost Test, Python unittest, NumPy, SciPy, Cython, METIS, git, CMake
Project Duration
September 2015 - March 2016
An Eigensolver based on AMLS and SIM
For the DFG research center Matheon project C22 and for the Einstein Center for Mathematics Project D-OT3, I implemented a solver for generalized eigenvalue problems arising from finite element discretizations in structural mechanics based on automated multilevel substructuring (AMLS) and the subspace iteration method (SIM). The findings were used in the paper Adaptive numerical solution of eigenvalue problems arising from finite element models. AMLS vs. AFEM (DOI: 10.1090/conm/658/13127).
Technologies Used
Matlab, METIS, C99, git
Project Duration
January 2013 - May 2015
Project Forschungskooperation Netzoptimierung (ForNe)
The project was concerned with the develop and implementation of mathematical optimization-based methods for checking realizability of stationary gas flow situations (paraphrased from here). My tasks included
- the statistical analysis of the customer-provided gas network,
- visualizing solutions computed with Lamatto++,
- dynamic visualization of gas flow in a gas network on a map of Germany in Google Earth,
- and aiding research assistants in comprehending and presenting computed solutions as well as gas network properties.
Examples of the visualization can be found in the figures of the article Gas Network Topology Optimization for Upcoming Market Requirements on the last page.
Technologies Used
C++98, Python 2, CherryPy, Google Earth, KML, XML, OpenGL 1.1, GNU Make, SVN, git
Project Duration
October 2009 - March 2012
Software for modeling and visualization of product-service systems
Details (in German)
Technologies Used
C# 3.0, Windows Presentation Foundation, .NET framework
Project Duration
April 2009 - September 2009
Compiler Back-End
For my bachelor's thesis, I added a compiler back-end generating JavaScript to an existing compiler for the simple functional programming language SL ("simple language").
Technologies Used
Haskell98, JavaScript (ECMAScript 5), HTML, git, SVN
Project Duration
July 2011 - October 2011