Tom Schouten

Extended CV

As an expert software developer with over 20 years of programming experience, I lead two lives. One as an embedded software engineer building high quality software, and one as an independent researcher and development tool builder. These two angles give rise to skills spanning breath and depth, theory and practice.


Fields of Expertise

  • Embedded Software Development
  • Numerical Computing: Signal Processing for Audio/Video, Computer Graphics
  • Programming Language, Runtime and Compiler Design

Team Integration

I've had the honor of working with an diverse set of people from all over the globe. People with often opposing ideas about how to design software, how to run a team, and how to balance code quality, feature set and delivery time.
  • 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.
  • I care. I have viscerally felt and successfully dealt with the pressure of time and dollar budgets, the limitation of inflexible tool sets, unexpected platform and problem constraints, personality clashes, communication challenges and the effects of stress on myself and others.
  • Fluent in Dutch and English, can read and understand French and German.

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
  • Model-Based Design
  • Excellence at simplification and refactoring
  • Testing and debugging expert: strong intuitive feel of how things go wrong, and where to focus effort while testing
  • Source control: git, darcs, SVN, CVS
  • Agile techniques
  • Broad understanding of algorithms and eager to learn new tricks.
  • Multithreading (shared resource & locking, message passing, dataflow, scheduling, RTOS implementation)
  • Reverse engineering
  • Code review, in both directions
  • When necessary: Duct Tape Programming

Programming languages

  • Expert: C, Forth, Microchip PIC assembly, Lua, Scheme, Haskell.
  • Proficient: C++, OCaml, Java, JavaScript, Objective C, Perl, Python, SQL, Matlab, Emacs Lisp, Pure Data, Latex, Shell. Assembler for x86, MMX, TMS320C40.
  • Studied: Common Lisp, Erlang, Prolog, Smalltalk, TCL, APL, J, Oz, Fortran, Fortress, Faust, Chuck, SuperCollider, Occam, VHDL, Assembler for ARM, AVR, MIPS, PPC, Z80, HC11, TMS320C6x, ...
  • Created: PF, SC, Staapl, DSPM, RAI.
  • Willing to learn: anything

Language / Runtime / Compiler design

  • Lifelong student of programming language, runtime and compiler design.
  • Language implementation in C, Forth, Scheme (Racket), Haskell and OCaml.
  • Implementation of minimalistic RTOS for bare-bones microcontrollers (Staapl on PIC) and soft real-time Audio/Video systems (PDP,PF,libprim on PC,Android).

Operating systems and environments

  • GNU/Linux expert
  • Proficient: Android, OpenWRT, OSX, eCos RTOS (ARM)
  • APIs: Linux audio/video APIs, OpenGL, Posix
  • Linux kernel and the Xenomai real-time extension
  • GNU binutils/GCC/GDB toolchain
  • Valgrind debugging
  • Makefile and build system design
  • Soft and hard real-time systems
  • Bare metal microcontrollers and DSPs
  • Low-level bit twiddling
  • Device driver implementation
  • Virtualization: VmWare, Qemu/KVM, Linux-VServer
  • Qemu peripheral device emulator extensions
  • Smart cards
  • Linux system administration: Apache, MySQL, Asterisk, Exim, OpenVPN, SSH, ...
  • MS Windows development: CMake, msbuild (VS2010), Python, Qt, Cygwin, MinGW

Numerical and Signal Processing

  • Continuous and discrete time SP theory, Laplace, Z-transform
  • Linear algebra, FFT, SVD, Wavelets
  • FIR and IIR filter design and implementation
  • Noise reduction, echo canceling
  • Feedback control for linear and non-linear systems, Kalman filter
  • Optimization theory, statistics, information theory, communication and digital codes
  • 2D/3D computer graphics,
  • Computer vision
  • Classical mechanics
  • Generic numerical algorithms
  • Audio effects and post-production processing, sound synthesis
  • Matlab/Simulink user experience
  • Mathworks Real-Time Workshop (Simulink Coder) code generation experience
  • Fixed point and floating point implementation


  • Analog and digital electronics, theory and practice
  • Simple circuit design and PCB layout (gEDA suite)
  • Circuit debugging using oscilloscope and logic analyzer

Project History

Zwizwa (November 2010 - present)

Zwizwa is the umbrella name my solo R&D work, focusing on the development of open source tools for rapid prototyping of low-level signal processing and digital control code.

During this period I employed the language design knowledge gained in the previous years to build RAI, an integrated analysis and implementation system for high-level DSP algorithm design. I use this system to develop audio processing and synthesis plugins for existing music production software and as stand-alone applications on mobile platforms.

  • Study of Digital and Analog circuit and signal processing theory.
  • Using Haskell and Racket as mathematical engineering design languages.
  • Staapl maintenance: API simplifications, internal dependency restructuring, custom PicKit2 interactive debugging driver, PIC USB driver.
  • Continuation of development of DSPM, a Domain Specific Language (DSL) embedded in Haskell as a precursor to RAI.
  • Design of RAI, a DSL embedded in Racket for the specification of digital signal processing algorithms, targeted primarily at music DSP.
  • Development of a compiler for RAI targeting the generation of digital audio effects and software instruments for VST (Windows, OSX), Pure Data and Jack Audio.
  • Development of several code analysis plugins for RAI: Z-transform of linearized transfer functions, Prolog-based logic analysis, automatic differentiation, various curve plotting tools.
  • Development of a binary object format facilitating on-line reload of DSP object code, significantly reducing the edit-compile-test delay.
  • Early design phase of a cross-platform fast-update OpenGL-based user interface library for controlling audio effect and synthesis software. Aiming at Windows, OSX, Linux, Android, iOS and smaller embedded systems.

Humanetics ATD (November 2014 - present)

System software and web interface for an in-dummy sensor network. Full software ownership. ARM Cortex A5 + M3. Embedded Linux and libopenCM3.

Emweb / Fike (January 2014 - present)

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

Beep (July 2013 - November 2013)

Tasks involved: absorbing a big stack of telco-related technical specifications, developing ISO7816-4 slave-side firmware for the Sysmocom SIMtrace (an AT91SAM7-based board), building an early exploration 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 as a telecommuting consultant 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. My contribution involved the design and implementation of:
  • Fault-tolerant Flash key-value store
  • Application configurability
  • Error reporting system: low-level remote device code + MySQL report generation
  • Debugging and tuning of LwIP embedded IP stack
  • Modifications and additions to remote firmware upgrade code
  • SPI Serial Flash driver (SST25)
  • Extension of a SPI serial UART driver (SC16)
  • Numerous code reviews
  • Review and improvement of accelerometer signal processing algorithms
I took part in continuous code reviews for ARM and PIC code additions, and wrote a large part of the test system:
  • Unit tests in C on eCos synthetic target, build-integrated.
  • Whole-application integration test system running in a simulated environment, Lua scriptable
  • C header data structure parser for extracting binary protocols (Haskell + Lua)
  • GDB-based target interface to connect PC-hosted test system to a running target board.

Zwizwa (April 2010 - July 2010)

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

Sony Techsoft Centre Europe (November 2009 - March 2010)

I was initially hired by Sony's software division in Brussels for a contracting job requiring Linux system programming experience and signal processing skills, but ended up writing a test system for Sony-specific modifications to the Android OS. This work involved coordination with development departments in Belgium, Japan and China. I took a deep dive into the Android system on all levels:
  • The high level Java API
  • Native C code libraries using the Java Native Interface (JNI)
  • C/C++ code on the system level
The system was delivered early. I spent the remaining time writing a small internal data display tool in JavaScript / JQuery.

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. I used my experience with prototyping systems from the audio DSP field to identify some of their deeper development process issues and provided a solution. Next to systems programming work, I assisted in day-to-day problem solving involving embedded PC hardware, Debian, Linux and Xenomai.
  • Design, implementation and ongoing refactoring of an application for the configuration and coordination of fieldbus systems (EtherCat and CANbus) and multiple Xenomai real-time control and measurement tasks.
  • Design and implementation of a low-level EtherCat fieldbus master driver as a Xenomai task, replacing a buggy in-kernel driver.
  • Gained familiarity with Real-Time Workshop, a framework for developing Matlab/Simulink code generation tools.

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.
  • Design of KRIkit, a tiny mixed analog/digital device for transmitting and recording audio signals, based on a PIC18F2620 microcontroller.
  • Basic PIC firmware and software for modulation and demodulation of OOK and PSK signals on sound wave carriers, all written in Forth (Staapl)
  • Updates to the Staapl programming system

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.
  • Continued development and documentation of Packet Forth (PF), Staapl
  • Technical support for the Metabiosis artificial life media art installation, written in PF
  • Development of CatKit, a tiny development board for Staapl, very similar in idea to Arduino.
  • I lead workshops about PF, Staapl and CatKit.

Zwizwa (April 2003 - October 2005)

After a couple of years in academe and industry, I embarked on a journey of prototyping tool development that is continuing up to this day. The following open source projects where initiated in this period:
  • 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)

I was contracted by Arboretum Systems, then a U.S. based company catering to the electronic music market, to become part of their Belgium-based team of developers. I took responsibility for the legacy code base of digital audio effects and licensed signal conditioning products.
  • Refactoring of legacy audio processing components (C++)
  • Porting to OSX for integration in the audio/video authoring tool HyperEngine-AV which was being newly developed.
  • Integration of company audio signal conditioning products in third party systems.
  • Designed the HyperEngine-AV audio time stretching engine.
  • Designed new audio processing algorithms and effects, including an improved noise reduction engine in Ray Gun Pro, and some Hyperprism audio effects.

SISTA lab, KULeuven (October 1998 - August 2001)

After graduating, I spent three years as a research assistant at my alma mater, working in the domain of signal processing for musical applications.
  • Study of the methods of analysis, modification and re-synthesis of high quality audio, using piecewise stationary signal models.
  • Development of a pitch-synchronous dynamic wave table synthesis method, related to scanned synthesis. This framework was implemented as an extension to Pure Data and later included in Creb as the dynwav~ object.
  • Refinement of a subspace based frequency estimation technique (HSVD) using a subband approach for resolving closely spaced signal frequencies.
  • Evaluation of trade-offs involved in FFT window design for additive sinusoidal synthesis.
  • Development of a method for alias-free synthesis of discontinuous waveforms using discrete state updates to a bank of damped oscillators.
  • Gained experience with the Matlab and Simulink prototyping environments.

Open Source Projects

I am a big fan of the free software movement. It has allowed people like me to build expertise without spending a fortune on education, or relying exclusively on an employer to provide an opportunity to obtain solid technical experience. This is a win for everyone involved. In an attempt to pay back part of this debt, I keep my my research logs and tools open. Over the last 10 years, the following projects have been released:
  • 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.
  • 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.
These and some smaller projects can be found at
Supporting blogs are at



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.


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


Autodidacticism. I experiment to find the limits of my understanding, to then find the the people to learn from next. 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 Synth engine, C++, Matlab, Perl
  • 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 embedded 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-2014 Erlang

The most recent version of this document can be found at