Tom Schouten

Extended CV
e-mail: tom@zwizwa.be
web: http://zwizwa.be


This is an extended CV covering a broad range of topics. Please send me an email if you would like a resume that is taylored to your application domain. I do wide spectrum embedded software development. I do best with early stage R&D work getting things off the ground, and I have a good eye for both architecture and implementation.

Skills

Fields of Expertise

  • Embedded Software Development (Linux, bare metal uC, FPGA)
  • Numerical Computing and Digital Signal Processing
  • Web-based user interface development with focus on embedded and real-time
  • Domain Specific Language (DSL) design in Haskell and Racket to support the above

Programming and Software Design

  • Full cycle software development: domain study, problem analysis, requirements gathering, design and prototyping, implementation, testing and debugging, continuous deployment, refactoring and maintenance
  • Object Oriented Design
  • Functional Programming
  • Domain Specific Languages for code generation and testing
  • Incremental simplification and refactoring
  • Testing and debugging expert: strong intuitive feel of how things go wrong, and where to focus effort while testing
  • Build automation and source control (git, darcs, SVN, CVS)
  • Broad understanding of algorithms and eager to learn new tricks.
  • Mapping a problem across the abstraction stack: FPGA (custom CPU + state machines), assembly, C, OS layers, high level languages, code generation.
  • Multithreading (shared resource & locking, message passing, dataflow, scheduling, RTOS implementation), actor systems.
  • Reverse engineering
  • Code review
  • Short cycle edit, compile, deploy setup for embedded systems (E.g. based on Erlang, Emacs, redo, GHCID and GDBSTUB)
  • Managing technical debt and "Duct Tape Programming".

Programming languages

  • Active non-trivial use: C, Forth, Scheme, Erlang, Rust, Haskell, ELisp, Bash, SQL, Nix, JavaScript, GNU Make.
  • Past non-trivial use: Lua, C++, OCaml, Java, Objective C, Perl, Python, Matlab, Pure Data, Latex, MyHDL, Assembler for PIC, x86, TMS320C40, ARM, PRU.
  • Explored: Common Lisp, Prolog, Smalltalk, TCL, APL, J, Oz, Fortran, Fortress, Faust, Chuck, SuperCollider, Occam, VHDL, Assembler for AVR, MIPS, PPC, Z80, HC11, TMS320C6x, ...
  • Created: PF, SC, Staapl, DSPM, RAI, Seq, PRU and the minimal Seq control CPU instruction set.

Language / Runtime / Compiler design

  • Lifelong student of programming languages, runtimes and compiler design.
  • Language implementation in C, Forth, Scheme (Racket), Haskell and OCaml.
  • Implementation of minimalistic RTOS for bare-bones microcontrollers (Staapl on PIC),
  • Virtual Machines for soft real-time Audio/Video systems (PDP,PF,libprim on PC,Android).
  • Implementation of bare-bones state machine host based on GDBSTUB (uc_tools).

Operating systems and environments

  • GNU/Linux expert, current focus on Debian, Nix, Buildroot and OpenWRT
  • Linux APIs: Linux audio/video APIs, OpenGL, Posix
  • Linux kernel and the Xenomai real-time extension
  • Erlang/OTP, rebar, and cross-language interfaces (ports and ETF)
  • Experience with Android, OSX, eCos RTOS (ARM), MS Windows
  • The Web platform: server side HTTP,SQL and client side HTML,CSS,JavaScript,WebSockets.
  • Haskell on Nix (cabal2nix)
  • Rust and Cargo
  • GNU binutils/GCC/GDB toolchain
  • GNU Make, redo, and incremental build + test + deployment system design
  • Soft and hard real-time systems
  • Bare metal microcontrollers and DSPs, FPGAs
  • Low-level bit twiddling, digital logic
  • Device driver implementation
  • Virtualization: VmWare, Qemu/KVM, LXC
  • Linux system administration: Apache, MySQL, Asterisk, Exim, OpenVPN, SSH, Borg backup ...

Numerical and Signal Processing

  • Continuous and discrete time signal processing theory, Laplace, Z-transform
  • Linear algebra, FFT, SVD, Wavelets
  • FIR and IIR filter design and implementation
  • Noise reduction, echo canceling
  • Control theory for linear and non-linear systems, Kalman filters
  • Optimization theory, statistics, information theory, communication and digital codes
  • 2D/3D computer graphics,
  • Basics in software-defined radio, classical mechanics, computer vision and generic numerical algorithms
  • Good understanding of audio effects and post-production processing, sound synthesis
  • Fixed point and floating point numerical code implementation
  • Bridge to implementation and testing: abstract interpretation, automatic differentiation, and code generation for C, assembly, LLVM targets.

Electronics

  • Basic familiarity with analog and digital electronics, theory and practice
  • Simple analog and digital circuit design and PCB layout (gEDA suite)
  • Circuit debugging using oscilloscope, logic analyzer and test code
  • FPGA digital logica design using MyHDL, Verilog, and custom Seq Haskell eDSL

Team Integration

  • I've had the honor of working with an diverse set of people from all over the globe. People with different ideas about how to design software, how to run a team, and how to balance code quality, feature set and delivery time.
  • I care and I finish what I start.
  • Worked in co-located teams, globally distributed teams, loosely knit open source communities and as a solo developer/researcher
  • Wrote user manuals, code documentation, informal articles and scientific papers
  • Gave presentations and played the role of tutor on development teams and in more formal workshops.
  • My mother tongue is Dutch and I speak native-level English with a mixed Flemish / Midwestern accent. I can read and understand spoken French and German for technical content.

Project History

Humanetics ATD (November 2014 - present)

Software design and implementation, and assistance with hardware design for data acquisition systems in a small team. I gained experience with designing, implementing, and managing the evolution of the software and digital logic for a fairly complex heterogenous system: FPGA, microcontrollers, application processors, Web platform server and client side software.

Zwizwa (November 2010 - present)

Solo R&D work. The open source projects are described elsewhere. This interleaves payed contract work.

  • Study: Digital and Analog circuit design, Digital Signal Processing theory, Programming Language theory, exploration of various open source tools.
  • DSL (Domain Specific Language) projects in Haskell (asm_tools, DSPM) and Racket (Staapl, RAI).
  • Support library development: uc_tools, erl_tools
  • Development of exo, an Erlang framework designed to support incremental development (continuous deployment) in a typical IoT setting, i.e. an always-on system consisting of servers and heterogenous collection of edge node embedded sensor/actuator systems. Includes Emacs, C, Rust, Haskell and JavaScript language and protocol bridges. Closed source, but many components are exposed in the open source libraries listed elsewhere.

Emweb / Fike (January 2014 - December 2015)

Design and implementation of a production test framework for a real-time industrial monitoring product. Full software responsibility. Host software in Python, test board dsPIC firmware in C. Tasks included debugging test board hardware, making circuit modifications, original analog/digital test circuit design, creating GUI and database.

Beep (July 2013 - November 2013)

Early stage consulting for an MVNO startup. Tasks involved: exploring telco-related technical specifications, developing ISO7816-4 firmware for the Sysmocom SIMtrace AT91SAM7, and building an early application prototype in Python.

Ubidata N.V. (July 2010 - March 2013)

I developed firmware for an application in the field of fleet management and remote data I/O running on AT91SAM7 and PIC16F. I worked on site for 3 months to get a redesign of an early prototype started, and continued remotely after moving to the U.S. I worked as part of a 3-4 people team of experienced embedded developers. The job spanned the full product life cycle, including the maintenance of a remote embedded system.

Zwizwa (April 2010 - July 2010)

  • Development of DSPM, a Haskell eDSL.
  • Reactive dataflow framework for sweb in Racket.
  • Study: classical mechanics and DSP theory

Sony Techsoft Centre Europe (November 2009 - March 2010)

I was hired by Sony's software division in Brussels for a contracting job requiring Linux system programming experience and signal processing skills. The product was a test system for Sony-specific media framework modifications to the Android OS. This work involved coordination with development departments in Belgium, Japan and China.

Zwizwa (March 2009 - October 2009)

  • Continuation of development of Staapl, sweb in Racket.
  • Study of programming language theory and implementation.
  • Development of libprim in C,Scheme.

Triphase N.V. (October 2008 - March 2009)

Triphase is a Belgium-based startup working in the area of rapid prototyping tools for energy conversion systems. I was hired for Linux/Xenomai driver development for EtherCat and CANbus systems. Aside from that I suggested and implemented some changes to their core product, adding configurability to the architecture. I gained experience with embedded PC hardware, Debian, Linux, Xenomai, field busses, and Matlab/Simulink Real-Time Workshop.

Zwizwa (December 2007 - October 2008)

  • Refactoring of the Staapl system based on insights gained from its use in the Waag project, and new insights in the use of Racket as a system for designing domain specific languages.
  • A short consulting project involving PF and a computer vision problem
  • Development of sweb, weblog software with Latex support used in my development logs

Waag Society (October 2007 - December 2007)

Artist-in-residence program at Waag Society in Amsterdam, institute for art, science & technology. This was a collaboration with Metabiosis/GOTO10. The project consisted of building the platform for an art installation, consisting of a collection of glowing orbs, communicating amongst each other using digital data transmitted over sound waves (OOK, PSL). The system used Staapl and PF.

The Packets Project (October 2005 - October 2007)

A two year project aimed at building tools for media artists. I was at that time part of the GOTO10 media art collective. The project was funded by the School of Art, Design and Architecture at the University of Huddersfield. Work included development of Packet Forth (PF), Staapl, CatKit (a Staapl PIC18F dev board), workshops, and technical support for the Metabiosis media art installation, written in PF.

Zwizwa (April 2003 - October 2005)

Start of solo R&D project work, mostly open source libraries:
  • PDP, a video processing extension for Pure Data.
  • Creb, a library of audio processing modules.
  • PF, a prototyping language for video and computer graphics.
  • Staapl (then called Brood), a low-level microcontroller metaprogramming system.
Next to software development, I lead hands-on workshops, gave invited talks and artistic performances.

Arboretum Systems (October 2001 - March 2003)

Part of a small software development team working on maintaining legacy audio processing software, integrating company IP in third party systems, and developing new audio effects.

SISTA lab, KULeuven (October 1998 - August 2001)

Research assistant in the field of signal processing for musical applications. Topics: Piecewise stationary signal models for audio signal modifications, pitch-synchronous dynamic wave table synthesis, scanned synthesis, subspace based frequency estimation techniques, evaluation of trade-offs involved in FFT window design for additive sinusoidal synthesis, and alias-free synthesis of discontinuous waveforms using discrete state updates to a bank of damped oscillators.

Open Source Projects

This is a chronological list of the projects I've put online, most recent first. The thread that runs through these is the synergy between embedded software, digital signal processing, and development tools focusing mostly on domain specific languages and interactive incremental development.
  • asm_tools Haskell eDSL library including two instrumented macro languages: Seq for sequential logic, and PRU for the AM335x deterministic embedded control processor. It uses a final tagless eDSL representation to implement validation and code generation from the same description. Basically, QuickCheck for machine code and digital logic.
  • uc_tools A collection of C macros for writing malloc-less, static-allocation state machines, and a minimalistic monitor OS based on GDBSTUB.
  • erl_tools Erlang support library for embedded systems applications, with some native C, Rust and JavaScript components.
  • studio Erlang MIDI studio.
  • RAI, short for Racket Abstract Interpretation, is a Domain Specific Language (DSL) for combined analysis and implementation of signal processing algorithms. Its main goal is to marry the process of high-level mathematical algorithm modeling, and the low-level implementation for a specific processor architecture. It does this by allowing multiple interpretations of the algorithm source text, e.g. as low level C code and as mathematical model, without sacrificing efficiency at the lower level. The practical driver behind the RAI project is the tuning and bringing to market of a large collection of original signal processing code designed in 2003-2005.
  • DSPM. Precursor to RAI, mostly of interest for theoretical purposes. This project explores the use of tagless-final embedding of a typed DSL into the Haskell programming language, exploring a recent development in typed metaprogramming and serving as a push for type theory study.
  • SISO. Tagless-final embedding of state space models in Haskell, based on Applicative Functors. Based on ideas behind DSPM and RAI.
  • Staapl is a metaprogramming tool for time/space constrained embedded systems. It is currently being developed for the the Microchip PIC18 architecture. Its design is based on a functional concatenative programming language model - a dialect of the Forth programming language. It is implemented as an extension of Racket (PLT Scheme) using its #lang facility. Staapl contains a tiny 8-bit sound synthesizer running in 2K of Flash which serves as test for the compiler, and a driver for generating PAL TV signals, used in the ForthTV workshop[1] [2].
  • libprim, a library for building small dynamically typed programming languages. Consists of a collection of OS abstractions, basic objects, a simple garbage collector, a Scheme interpreter and a rework of the PF core language and virtual machine. It is targeted mostly at embedded systems and has a similar scope and complexity as the Lua language.
  • sweb, a Racket-based web application hosting my web logs with support for rendering posts of mathematical nature written in Latex. The design is based on a reactive programming engine.
  • Packet Forth (PF), a stand-alone dynamically typed scripting language taking ideas from Forth and Scheme, aimed at video processing using C-based signal processing code plugins.
  • Creb, an extension for the computer music system Pure Data. Creb adds building blocks for music DSP that were missing in Pure Data, or are the result of my research on audio synthesis techniques.
  • Pure Data Packet (PDP), another extension for Pure Data, which adds building blocks for image and video processing.
  • Pyla real-time protocol analyzer with support for the Saleae Logic. Written in Python combined with C++/Swig for the analyzer modules, and LARS, a Rust port of Pyla.
These and some smaller projects can be found at http://zwizwa.be/darcs and https://github.com/zwizwa.
Supporting blogs are at http://zwizwa.be/-/topics.

Education

1998-2001

Graduate courses and seminars @ KULeuven, Belgium: optimization theory, statistical learning theory, neural networks, system theory, identification and control, numerical algorithms, computer architecture and advanced signal processing.

1993-1998

Master of Electronics Engineering (Burgerlijk Elektrotechnisch Ingenieur) at the KULeuven, Belgium, with a major in Digital Signal Processing.

1987-2017

Autodidacticism. Of course I'm glad for having received a formal education, but it appears most practical applicable knowledge comes from following curiosity. This is a short summary of the path I followed.
  • 1987-1989 MSX BASIC, Z80 assembler
  • 1989-1991 MS-DOS, Pascal, DEBUG.COM, 8086 asm & arch
  • 1991-1993 Borland Turbo C/C++ & Debugger, 80386 asm & arch, 2D/3D graphics, sound
  • 1993-1997 Electronic music, hardware synthesizers, analog & digital electronics
  • 1997-1998 Linux: RedHat, Suse, Debian, system administration
  • 1998-2000 C++, Matlab, Perl, wrote an audio synthesizer engine
  • 2000-2002 Pure Data, computer music & signal processing, GCC/GDB, Linux development, wrote creb
  • 2002-2004 Python, emacs, video processing, wrote PDP
  • 2004-2006 Forth, Scheme, language & VM design, wrote PF
  • 2006-2008 OpenWRT and embedded Linux, Microchip PIC asm & arch, ColorForth, compiler design, wrote Staapl, sweb
  • 2008-2010 Scheme (Racket) and programming language theory, wrote libprim
  • 2010-2012 Haskell, type theory, and domain specific language design, wrote DSPM
  • 2012-2013 back to DSP theory, wrote RAI: a language for DSP algorithm design
  • 2013-2014 Python Qt GUI and MySQL, SQLite database, wrote Pyla, Staapl development
  • 2014-2017 Erlang, MyHDL (+ VHDL/Verilog), Analog Electronics, RAI & Staapl tweaks, wrote SISO
  • 2017-2019 Erlang, Rust, Haskell, Buildroot, digital logic, Web technology. Focus on integration and incremental development of distributed systems.


The most recent version of this document can be found at http://zwizwa.be/tom/cv.html