About Me

My name is Aaron Boman and I am a Software Engineer. I am
currently located in the Kansas City area with my
loving wife Rachel. When I'm not working I can
usually be found doing something with a computer. I
enjoy learning new things and I usually start projects
just so I can learn a new technology.

Experience

Garmin

June 2013 - Present

Senior Software Engineer &dash; Aviation Tools | Web Development

I am currently working on the Web Technology tools team using
React, Typescript, Electron, and NodeJS to make desktop
and web applications. My latest project was creating an Electron desktop
application that can be used to provide configuration for our
embedded machines (each aircraft requires a separate configuration).

Before moving to the Web Team, I was in charge of writing, testing,
and maintaining Python tools that helped to facilitate our embedded
software development. We use
Boost.Build to
build our embedded software. I was in charge of converting
the backend code (written in Boost.Build's Jam language)
over to Python. In so doing I found several bugs in
Boost.Build's core Python code and have submitted
several pull requests (all can be found here).
I was later deemed a trustworthy contributor and have
been granted master privileges on the open source
Boost.Build project. One of my most prized contributions
would be the optimization changes I've submitted to the
Python port. On one specific test project I improved the
Boost.Build run time from 2 minutes down to 30 seconds
(which is on par with the Jam code). The optimizations
were only for speed, but I have some ideas on how to optimize
for space (on larger projects, it will easily blow through
Windows' 2GB process limit) using weak-ref dictionaries.

I have a very intimate knowledge of Python and its ecosystem.
My first two days at Garmin I spent reading the entire Python
documentation just to become familiar with all of the standard
library modules and functions. Python never ceases to amaze me
as there is always something to learn about it.
Additionally, I have experience with writing with the C API.
Most of this experience was required in order to interface
with the Boost.Build Python port.

In my spare time, I have been learning about the Rust programming
language and finally had a chance to put it to use at Garmin. We
needed a compiled tool (for obscurity more than speed) and I wrote
a quick prototype in a few hours with Rust and submitted it. So
far, I'm having a blast with Rust and and looking for more areas
to use it.

Garmin

May 2012 - June 2013

Software Engineer Intern &dash; Aviation

I was initially hired on at Garmin as an intern because of
my web development experience, however, I showed an
interest in learning the closer-to-the-metal embedded systems
work. So, my first
couple of weeks were spent learning about the C language
as well as some aviation software fundamentals through
unit testing. When creating tests, there was no good way
to determine the dependencies that the particular test
needed. Usually the process went something like this:
try to compile, wait for the compiler to gripe about
certain functions not being found, look up where those
functions are declared, and add those files as a dependency.
An intern on my team spent upwards of 2 hours trying to
resolve all dependencies before starting to write a test.
So, being fed up myself, I wrote a quick python script
to help automate the process. It wasn't perfect, however,
within 10 seconds, you would have the majority of the
dependencies needed for the test. I spent about 2 hours
on the script and it saved my team hours. It was due to
events like this that led to an eventual offer of
full-time employment and a spot on the tools team.

Missouri State University

June 2011 - May 2013

Web Developer &dash; ResNet

I worked on a team of three at ResNet. Our job was to write
and maintain web applications for ResLife. The main
application we wrote during my employment was a dashboard
application for reception desk workers at each of the
residence halls at MSU. It maintained information about
the students at the building including equipment rental,
the number of times a student was locked out of their room,
the student's roommates, packages/mail in their mailbox, charges incurred, etc.
When I first started this job, I didn't know much about
programming in general. I started at the beginning of
summer 2011. The following fall semester I had learned
so much that my classes became painfully simple. One of
the things that I learned with this job is that
real world problems and experience trumps purely academic
exercises every time. Check out ResNet's
GitHub account
for examples of some of the projects I've worked on.

Databases

Tools

Education

Missouri State University

January 2011 - May 2013

BS Computer Science | Minor Mathematics (3.54 GPA)

The beginning of my education was primarily Java-based
programming. After exploring introductions to binary, hex,
and logic, we began to discover Object Oriented Programming
and finished the foundation by learning data structures.
My favorite two classes would have to be the Languages &
Machines class (learning about languages in terms of computers
and intro to compiling) as well as the Operating Systems
class. The OS class was the culmination in my studies
since it was the application of everything I had learned.

MetrolpolitanCommunity College

September 2008 - December 2010

Associate of Arts (3.0 GPA)

My schooling here was primarily General Education.
I had originally thought that general education classes
were completely pointless, and from a Software
Engineering career standpoint, most are. However, it
was in these first couple of years that I figured out
what I wanted to do for a career. If I had jumped right
into a four year degree program at some university I
would have started on a Computer Animation career path
and I most likely would not have ever touched programming.

Projects

In my spare time I'm usually working on some sort of
project. These Projects can help further an
understaning on a subject, help me learn a new
technology, or help others.

Ubuntu Servers

I have and maintain a couple of VPSs for some websites
I host, experimentation, an Matrix synapse server, git repos, etc.
I have an instance of GitLab
running for personal projects. When I first got started
maintaining an Ubuntu Server, I used nano to edit files.
One day, I finally decided to grow up and learn something
a little more powerful: Emacs.

My Own OS

My OS class taught me a lot about operating systems.
However, I still had a lot of questions about the
implementation of an OS. Sure, I could pour through
the Linux source,
but I learn best by doing. So, I set off reading
through the wonderful articles over at
OSDev.

WebGL OBJ Loader

I took a computer graphics course while completing
my Bachelors degree at Missouri State. There
came a time when hand-coding or dynamically generating
cube and sphere models just wasn't fun. Since I was
originally double majoring as a computer animation student
I had experience with creating and handling 3D models.
With help from a friend and the
OBJ format wiki
I implemented a JavaScript OBJ model loader. Upon completion,
I open-sourced the loader and
pushed to GitHub so that my class
and hopefully any other class learning WebGL might have an easy
way to load 3D models into their scene.

WebSocket Chat App

I wanted to learn more about the browser
WebSocket API as well as the WebSocket protocol.
I wrote a simple chat application
for the browser that sends a username to the server,
logs the user in, and waits for messages from other users.
I wrote the server from scratch using Python's socket
module and the spec for WebSocket. The server waits
for a connection. When a client connects, the client
initially sends an HTTP(s) request with a randomly generated
key and a request to upgrade the following conversation to
the WebSocket protocol. The server takes that key,
sha1 hashes it with a Magic String, and returns an HTTP(s)
response stating whether the server accepts the connection
or not. After a successful handshake, the client is able
to send messages to the server using the WebSocket protocol.
The server strips the payload from the frame and
unmasks the data using the client-provided mask key.

Raspberry Pi Lightbox

Not too long after my son was born, I noticed that
he liked to look at fans while they were spinning.
A co-worker of mine told me about a light box he
had built with an arduino. It's a shadow box
with a strand of LEDs inserted into the back and
a translucent sheet of plastic on the front to
diffuse the light of the LEDs. So, I built one myself
using a Raspberry Pi Zero W instead of an arduino.
At first, I used a Python library
to write some simple animations, but found out quickly
that the floating point calculations required for
more complex animations were too much for Python.
I had been dabbling with the Rust programming language
and decided to try and port over to it. I found
an existing library
to interface with the LEDs, but it was incomplete. So,
I completed the API and created a pull request
which was merged into master. With all of this complete,
I was able to use Rust to control my lightbox.

Cryptocurrency Trader Bot

During the crypto hype of 2017, I decided to play around
with creating a trader bot. This was written completely in
Python 3.6 and used Binance's REST API to fetch data.
I created a simulator that would iterate over saved data
to simulate buys/sells and spit out a visualization along
with a summary of all of the transactions. Eventually, I
created a command line option that would iterate over a series
of settings and run a simulation per configuration to try
and show which settings had the most effect on the output;
a DOE (design of experiements).