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.
June 2013 - Present
I work on the tools team for Garmin's aviation division. The tools team is in charge of developing and maintaining tools that is then used by Aviation's embedded developers. I am Aviation's resident Python expert. During my time here, I have written and re-written most of the Python-based tools. 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 am mostly working on Python projects now. We have been creating a few new tools and libraries recently and we want them all to obey our strict Python project guidlines. To make this easier, I wrote a tool on top of the Python Cookiecutter projecct that will prompt some standard questions and then dump a new project using configuration from the answers. This new project sets up the a skeleton of the project complete with source, tests, and documentation directories. It also comes with support for tox and all of the different tests/checks we want to have run on the project including pycodestyle, pylint, pylint3k compatibility, tests with coverage, and Sphinx documentation. This makes third-party (other teams) code contribution easy and makes maintaining the "golden master" standard much easier: all changes must first be rebased onto the current master and then pass tox on the continuous integration server, Jenkins. Upon success, the changeset can then be brought into master.
When I'm not writing or testing tools, I can be found providing reviews on Python code. Most of the developers in Garmin's Aviation division are embedded developers and are most adept at C. Some know a little Python, but typically write C in Python; it's mostly procedural and very low-level, not using idiomatic Python.
Olathe, KS | http://www.garmin.com/
May 2012 - June 2013
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.
Olathe, KS | http://www.garmin.com/
June 2011 - May 2013
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.
Springfield, MO | http://resnet.missouristate.edu/
January 2011 - May 2013
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.
Springfield, MO | http://www.missouristate.edu/
September 2008 - December 2010
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.
Lee's Summit, MO | http://mcckc.edu/
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.
I have and maintain a couple of VPSs for some websites I host, experimentation, an IRC 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 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.
While trying to write and build a kernel image for my operating system, I found a need for a build system that would play nice with OS building. I originally had been using GNUMake, but I didn't care for the implicit rules and globbing style. After researching alternative build systems, like Boost-Build and Waf, I decided to just write my own. I mean, why not? I'm already writing my own OS to understand it, why not get a better understanding of a build system while I'm at it?
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.
I have a friend who came to me for my website expertise. He had previously purchased a template for his website and wanted me to put it all together for him. He wanted the ability to edit almost anything on the site as well as having blog, photo gallery, and podcast features. Originally, I started to write a Django application from scratch as that was all that I had experience with. The feature parts were easy, however, the work became very tedious upon reaching the editable sections. My naive implementation didn't allow for customization and it wasn't very robust. At this point I started research on CMSes. I looked at Druple and Joomla. They had the maturity I was looking for with the customization that I had desired, but the development environment was awful, not to mention the installs failed several times. I was introduced to Wagtail CMS and I fell in love with its beautiful admin interface. However, I wasn't too crazy about its lack of placeholders. I finally tried Django CMS 3.0 (beta). It's frontend was awesome, the plugins are easy to create, and it has the placeholders I like. The biggest problem with it has to also be the biggest problem with Django in general: anyone that is not a python programmer will be lost in trying to develop templates.
When creating the website for my friend with Django CMS, it wasn't easy to allow a designer to work on the code simultaneously due to the need for python. I really think Django CMS is an awesome way to build quick dynamic sites and a lot of the features/plugins that I wrote by hand could be automated. So, just like everything else I do, I am currently in the process of writing a program to help build Django CMS sites without any programming knowledge. It uses PySide to create a control panel similar to XAMPP and EasyPHP that allows a user to pick a Django CMS project and start a server for it. A feature I plan on implementing will be a way to create custom plugins without writing a single line of code.
I wanted to learn more about REST APIs as well as thick clients. So, I wrote a simple pastebin that utilized the Django REST Framework and Pygments on the backend and AngularJS for the frontend. I have to say that I definitely enjoyed completely removing all display from Django and using it primarily for its routing and ORM and I plan on creating more applications like this in the future.