Hi, I am

Andreas.

Physicist turned software engineer.

I work with C++ and Python on automotive projects, with a passion for algorithms, complex systems, and open-source contributions in C++, Python, and Go.

About Me

I’m a software engineer with a background in theoretical physics, working primarily in automotive software development. Over roughly ten years, my work has included C++ development for sensor-related systems (camera, LiDAR, radar), Python-based sensor data analysis, and the development and maintenance of automotive-safe C++ core libraries.

I also contribute to open-source codebases, particularly in the area of graph algorithms and performance optimization. This work usually involves algorithm implementation, performance-focused refactoring, and the addition of tests and benchmarks, with contributions merged into established projects.

I’m interested in algorithms and data structures, and in understanding their performance through profiling and reproducible benchmarks. Alongside my core work, I’m gradually expanding my exposure to Go-based projects, build systems, and containerized workflows to broaden my perspective on large-scale and distributed software.

Technologies and areas I actively work with include:

  • Modern C++ (performance-critical systems, algorithms)

  • Python (scientific computing, tooling, bindings)

  • Graph algorithms and network analysis

  • Go (learning, selected open-source contributions)

  • CMake (regular use)

  • Bazel, Docker (introductory / exploratory)

Experience

Robert Bosch GmbH - Product Owner

Product Ownership & Leadership

  • Led the consolidation of two parallel C++ base-library initiatives into a single cross–business-unit platform, securing executive approval and establishing clear ownership, strategy, and roadmap.
  • Defined the long-term vision and architectural direction for a shared C++ foundation, aligning stakeholders across units on scope, quality standards, and delivery expectations.
  • Acted as the primary interface between internal customers and engineering, balancing requirements, prioritization, and technical constraints across multiple teams.

Hands-on Engineering

  • Continued contributing as an active C++ developer alongside product ownership responsibilities, unblocking critical paths and addressing high-impact issues across feature streams.
  • Transferred and introduced established performance benchmarking practices from prior core-library work, seeding initial benchmarks and setting expectations for performance-aware development across feature streams.
Robert Bosch GmbH - Senior SW Developer

Development of an automotive header-only C++ library

C++

  • Improved runtime performance of selected C++ APIs by up to 17× by implementing a benchmarking framework that measured instruction counts and CPU cycles across four compilers.
  • Achieved 2× faster runtime for trivial types and 5–20% lower memory use in embedded automotive systems by implementing a template specialization for a std::optional-like type.
  • Boosted runtime performance in release builds by ~10% across 10+ customer compilers by adding move semantics to fixed-capacity containers (vectors, lists, maps), benchmarked with Google Benchmark.

Python

  • Reduced maintenance load by ~5% by automating analysis of 20+ customer repositories, identifying 50 unused public APIs and driving deprecations.

Leadership

  • Fostered a customer-centric team culture by prioritizing feature requests in the backlog, organizing them into epics/stories, and implementing the first requests, leading to active developer engagement with customer needs.
  • Converted a frustrated customer into a satisfied one by establishing and carrying out the Developer Relations Engineer role, directly addressing customer developers’ issues.
Robert Bosch GmbH - SW Developer

Task force support: Refactored GPS-Based Route Prediction Component

C++

  • Reduced code complexity by 25% and eliminated 1,500+ lines in real-time radar-based situation interpretation algorithms through template-based redesign and restructuring of “iceberg classes.”

Python

  • Reduced development time by 33% during a tight project deadline by implementing a Python-based automated toolchain that tested thousands of output signals for functional correctness during code refactoring.
  • Accelerated rare-event detection by ~40× by implementing Python scripts to retrieve, convert, and analyze ~1,000 recorded sequences from radar-based driver assistance systems.
Robert Bosch GmbH - Research Engineer
  • Developed and maintained C++ modules for camera image and metadata processing to support labeling and training workflows.

  • Administered an Azure-hosted SQL database for image metadata and label storage, ensuring reliable data access and schema evolution.

  • Integrated Azure DevOps and Azure ML pipelines to automate label data deliveries and schema updates.

  • Expanded Azure ML pipelines and SQL-based workflows to improve data handling, scalability, and pipeline functionality.

  • Developed a deep-learning–based prototype for LiDAR blockage detection in Python, achieving ~90% detection probability in staged pollution scenarios.

  • Performed in-depth analysis of LiDAR sensor performance under diverse contamination scenarios, identifying key factors affecting accuracy and reliability.

  • Engineered and extended a Python preprocessing framework for point cloud data, supporting multiple LiDAR types (multi-return, intensity, and other features) to streamline training data generation and augmentation.

  • Created accurate LiDAR sensor models to enable comprehensive sensor-set evaluations.

Leadership

  • Coordinated the development of the first multi-sensor 3D box labeling toolchain, streamlining annotation workflows across multiple teams.
ITK Engineering & ASAP Engineering - SW Developer

Projects

  • Analyzed large-scale mobility data using Python, extracting insights for customer research projects.
  • Implemented a new API in the customer’s C# software stack, enabling smoother system integration.
  • Debugged the Fresnel integral calculation in customer C++ software to ensure accurate road curvature computation.
  • Evaluated real-time performance of charting and plotting libraries (C++/C#) on customer hardware, guiding technology choices.
  • Developed C# desktop software to analyze electronic control units (ECUs), improving diagnostic capabilities.

Leadership

  • Led and coordinated a team of five developers to refactor a customer’s Java software system, improving maintainability and project delivery.
University at Buffalo (USA), University of Würzburg (Germany) - Postdoctoral Researcher

Postdoctoral Researcher in Theoretical High Energy Particle Physics

  • Conducted large-scale numerical computations and Monte Carlo simulations in quantum field theory.
  • Published in peer-reviewed journals and presented at international conferences.
  • Supervised doctoral students and contributed to collaborative research projects.
  • List of publications

Education

Sep 2004 - Sep 2008
Doctor rerum naturalium (PhD equivalent)
Karlsruhe Institute of Technology (KIT), Germany
GPA: magna cum laude
High-energy particle physics. Conducted in-depth research and numerical computations, resulting in publications in peer-reviewed journals.
Oct 1998 - Aug 2004
Diplom in Physics (equivalent to M.Sc.)
Karlsruhe Institute of Technology (KIT), Germany
GPA: grade 1.1 (sehr gut, ≈ GPA 3.9–4.0 / A)
Comprehensive study in various fields of physics, honing analytical and quantitative skills.

Open Source Contributions

NetworKit — Graph Algorithms & Performance (C++ / Python)

Selected feature contributions

  • Left–Right Planarity Test
    Near-linear-time planarity check based on the Left–Right algorithm; full C++ implementation with extensive tests.
    • Initial implementation: PR #1276
    • Performance rewrite: ≈100× faster isolated runtime (Google Benchmark) and up to ≈20× faster planarity test-suite: PR #1377

    LeftRightPlanarityCheck runtime (Google Benchmark)
    LeftRightPlanarityCheck instructions (Callgrind)
  • Floyd–Warshall with OpenMP parallelization
    All-pairs shortest paths with shared-memory parallelism; performance study on bit-level containers.
    ~40% fewer dynamic instructions using std::vector<uint8_t> instead of std::vector<bool>.
    PR #1312

  • Successive Shortest Path (min-cost flow)
    Computes minimum-cost flows under capacities and supplies/demands.
    PR #1349

  • Maintenance & ecosystem work
    Ongoing features, bug fixes, code-quality improvements, Python bindings, and developer tooling.
    Merged PRs

Gonum — Algorithms & Numerical Computing (Go)

Selected algorithmic & numerical contributions

  • Dinic’s algorithm (max-flow)
    Level-graph & blocking-flow implementation.
    PR #2051

  • Dilogarithm (Li₂) — implementation & optimization
    Numerically stable special function used in physics and number theory.
    • Initial implementation: PR #2059
    • Performance & benchmarks: PR #2062 Dilogarithm speedup on a log10 scale.

    Dilogarithm speed up for 11 selected points.
Additional Open-Source Work
  • NetworkX (Python)
    Bug fixes and correctness improvements in graph algorithms.
    Merged PRs

  • DuckDB (C++)
    Large-scale include cleanup removing unused headers across many files; improves dependency hygiene and maintainability.
    PR #18422

  • TiDB (Go)
    Exploratory contribution to a distributed SQL database; initial PR under review.
    In progress

Get in Touch

My inbox is always open.