Colin Davidson — Systems and Backend Programmer

 Github Portfolio

I'm Colin Davidson, and I'm looking for a job as a programmer. I have experience with building full backend systems, creating simple web UIs, and working directly with low-level hardware. I'd love to work on any of those, or anything in between. I'm currently in Seattle, but I'm willing to move.

Skill Summary

  • production experience in Python, Rust, C, and JS
  • low level programming, web backend, robotics, emulation

Selected Projects

Siege Technologies Siege Rust Rust FIRST Robotics FIRST Q8 Q8 GB Emu GB Emu Nolli Nolli Zala Zala Snow Snow Rain Rain

Siege Technologies Siege Technologies

Linux Kernel Module Toolchain

  • custom Linux kernel module
  • clear, concise UI to enable users to interact with data
  • Rust webserver to seperate platform-independant data processing from UI
  • performance impact: workflow took nearly 24 hours, now done under 10 sec.

I worked as part of a 2 person team implementing a custom Linux kernel module for a cybersecurity application in 3 months. I wrote a mini data visualization server and web client in Rust and Javascript, and the core application in Python and C, learning professional software development practices. This experience has prepared me well to approach other complex systems in many domains.

	// basic structure of a Linux kernel module

        #include <linux/module.h>
        #include <linux/kernel.h>

        int init_module(void) {
            printk(KERN_INFO "Hello world!\n");
            return 0;

        void cleanup_module(void) {
            printk(KERN_INFO "Goodbye world!\n");

Over the course of my internship, I designed and shipped a user-facing feature in Siege's product, reducing deployment time for the application from nearly 24 hours to under 10 seconds by simplifying the user workflow and pulling out unnecessary setup dependencies. In addition to meeting hard security constraints, primarily through code review, I also had to support multiple hardware architectures and provide backwards compatibility for older Linux kernel versions.

Rust Rust Contributions

Rust Commits

  • made small accepted commits to major open source project
  • identified issues that I could tackle and collaborate with an open source team
  • learned github-based issue/fork/PR/review-based development workflow

I have been learning Rust and using it in a variety of my own projects. Along the way, I've added minor features to improve my own project development experience, submitting accepted upstream commits along the way.

While working on some basic crypto programming challenges, I discovered that the Rust biguint library didn't have any code for printing biguints in hex. As part of my validation and testing process for the project, I added that feature in my own personal fork, eventually submitting it after approval by the rust-num dev team.

FIRST Robotics FIRST Robotics

Any-Direction Drive System

  • used low level protocols like i2c and SPI
  • implemented PID control loops
  • worked on robot chassis with omnidirectional motion and rotation
  • experienced and addressed the challenges of real hardware behaviour

From 2012-2014, I participated in FIRST Robotics, working to solve challenging problems with my team. I built a platform that could drive in any ordinal direction while simultaneously rotating by communicating with a 9 degrees-of-freedom compass/accelerometer/gyro package over i2c.

Chassis View

The chassis supported both field-relative and robot-relative driving schemes, allowing you to push forward on the control stick, moving the robot away from you, or to push forward, and drive in the direction of the robot's front.

Field View

I implemented a PID control loop to improve motion accuracy. PID requires tuning, and can cause funny behavior when it's poorly calibrated. The robot had an oscillation problem for quite a while as a result of the poor tuning, making aiming with the balance ball launcher a nightmare. We did eventually get the tuning right. Properly corrected, it went on to win regionals.

Quine8 Quine8 (Q8)

Interactive Bytecode VM

  • complete program runtime visualization
  • visual data processing overlay
  • full system documentation
Q8 Github
Q8 Live

Q8 is an educational tool, designed to show the users what really goes on under the hood of their computer. Using a grid of tiles, it renders the state of the program in memory live, highlighting I/O operations as they occur. With a comprehensive suite of example programs, puzzles, and intro tutorials, users can quickly get a feel for working with a machine on the lowest level, bytecode. Without the abstractions of higher-level languages or even assembly, it provides a framework to make comprehension of low-level computing building blocks, easy.

Multiplication Program

Q8 provides only the most basic of operations, giving new users lots of runway to grow. Need multiplication? Write it yourself using addition and a loop, and learn a lot about programming while you are at it.

GB Emu GB Emu

Gameboy Emulator

  • Z80 emulation
  • Readable program dissasembly
  • Interactive debugging system
GB Emu Github

GB Emu is a long-term emulation project of the classic Nintendo Gameboy. The Gameboy has a Z80 CPU, a 160x140 LCD, and swappable memory banks built into the cartridge. Because the opcodes are not fixed width, and the program in memory can self-modify and swap addresses via the bank system, building a stable debugger and disassembler was absolutely essential.

Pokemon Yellow

The gameboy emulates a CRT using a timer count to render "scanlines" and providing emulated vblank interrupts. Because it doesn't have enough memory to map VRAM to local space, it has to use a tiling system, reducing the amount of memory that the hardware needs mapped at any one time significantly. To access the next tile for editing, the ROM writes a couple bits to address FF40 in the high memory mapped region.

To properly debug the emulator, I wrote a disassembler that does pretty printing of opcodes, enabling me to walk through the binary step by step and verify against other stable debuggers that my emulation was running correctly. I added support for arbitrary speed manipulation to let me step through a binary, line by line, for critical points and speed through segments that I had already verified.

Nolli Nolli

Hobby Kernel

  • x86 homebrew kernel
  • Custom bootloader
  • Identity Mapped Paging
Nolli Github

Nolli is a tiny hobby kernel that runs on x86. It has a two stage bootloader that pulls it from the primordial 16 bit start state up to a slightly less archaic 32 bits, heroically saving the poor processor from the horrors of the segment registers.

PCI List

As a learning project primarily, the kernel regularly suffers bouts of triple fault fever, getting better over time as I work out some of the nasty issues. It currently supports basic interrupts and catches some faults; It responds to keyboard input, page faults appropriately on invalid accesses, and can scan the pci bus for attached devices. Nolli can output over both serial and vga, using the BIOS configured VGA mmio at 0xB8000 to draw ascii symbols in various colors.

The bootloader is simple, using bios int calls to build a map of memory, load the kernel from disk, configure the gdt, and transition into 32 bit mode.

Zala Zala

Space Programming Game

  • 2D OpenGL rendering engine
  • 2D physics with timestepping
  • Real-time pseudo-CPU emulation
  • Assembler to bytecode to runtime toolchain
Zala Github

Zala is a side-project that I developed over a period of time after wanting to see a solid space programming game similar to Mojang's 0x10c. Zala has an in-game console and assembler, using an emulated CPU to process instructions. The player can open doors, fire turrets, and fly the ship with a simplified assembly language.

Zala Term

To support a live programming/runtime environment I had to encapsulate the emulator, running it at a fraction of the framerate and sending it a reset flag when new code was available. I created a little messaging system to report errors and CPU output back to the game.

As part of the game, I had to lay out a very simple set of assembly instructions, creating an easier, programmer friendly environment. The assembler allowed for jumping to labels and all the opcodes had one distinct function.

Snow Snow

Voxel Terrain Engine

  • powerful 3D OpenGL voxel engine
  • instanced rendering
  • hulled terrain mesh to lighten GPU load
  • fast, efficient ambient occlusion
  • procedurally generated mountains and plains to explore
Snow Github

Snow was an experiment into procedural terrain generation and 3D rendering using OpenGL. While learning to render tons of 3D models each frame, I picked through several techniques, trying to get the smoothest framerate for the largest visible number of voxels. I tried using the CPU to create a mesh containing only the visible faces of the terrain, but quickly discovered that doing that created a large amount of vertex processing on the component not designed to handle it. I found that instanced rendering of full cubes moved the vast majority of processing to the gpu instead, and the only work the cpu had to do was to compile a list of cube centers for the hulled mesh.

Terrain Huller Large Map Test

Using perlin noise, I rapidly generated interesting terrain for the player to explore. Interesting terrain gave me a strong reason to work on the hull meshing. I wanted more to explore and see from a distance.

One of the biggest issues with voxels, especially non-textured voxels, is the need to differentiate between flat surfaces and edges. I wrote an edge detector that processed vertices and applied lighting modifiers when appropriate, emulating ambient occlusion.

No Ambient Occlusion Ambient Occlusion Alternate Ambient Occlusion Terrain Meshing

Rain Rain

Isometric Squad Tactics Game

  • SDL2 2.5D isometric engine
  • pathfinding, fog of war, and tactical AI systems
  • dynamic user input handling
Rain Github

Rain's rendering engine positions and draws 2D tiles to give it a 2.5D isometric feel. In order to support camera rotation, the engine selects pre-made tiles from each tile type's palette. To simplify mouse detection while my grid placement and block size were still undetermined, I constructed a screenspace to worldspace map so that mouse clicks would map perfectly onto pixels, regardless of orientation.

Mouse Click Detection

Rain uses a breadth-first search pathfinder to move the player characters around the map. The player can then select enemies to attack, assuming the player characters can see them. To manage vision, each entity adds the surrounding circle of tiles into their team's visible tile list.

Rain Menu

Hire me!

If you think my projects are interesting, I may be a good fit for your company.