About

Resume

Welcome to the resume of John A. De Goes -- computer scientist, software engineer, and (most recently) team leader and project manager.

This is where I try to convince you I'm worth hiring. If I'm already working for you, this is where I try to convince you to pay me more.

Platforms

Win32, Windows 95, Windows XP, Windows 2000
HP Unix
Solaris
Linux (RHEL, CentOS)
Mac
FreeBSD

Languages

C++ - 15 years
Java - 5 years
Mathematica - 4 years
C - 2 years
Shell scripting - 1 year
Clean - Learning
Ruby - Learning

Tools

Microsoft Visual C++, IntelliJ Idea, gcc, g++, Metroworks CodeWarrior C++, Eclipse, Borland C/C++
Nedit, vi, TextMate
make, Ant
Perforce, Subversion, CVS
gdb, DDD, JSwat
Valgrind, Purify, Coverity
xUnit, Cobertura

Practices

Object-Oriented Analysis & Object-Oriented Design
Unit, Functional, Stress, Regression, and Acceptance Testing
UML, CRC
Test-Driven Development
Pair Programming
Agile Development
Refactoring
Continuous Integration
Build & Test Automation
Vertical Slice Development
Black Coffee Drinking

Skills

Critical thinking & problem solving
Fluent oral and written communicator
Complex algorithm development & implementation
Quickly learning new languages, tools
Systems engineering
Scientific, media, and game software development
Self-motivated, self-pacing, and goal-driven, with no need for supervision or micromanagement
Excellent teaching skills
Effective leader of small teams

Philosophy

I believe in strong encapsulation and data hiding, to minimize coupling (the bane of software maintenance)
I believe in object-oriented design, because it reduces coupling and enables comprehension at a fine level of granularity
I believe in design patterns, not as rigid blueprints to be followed without deviation, but as platforms of inspiration
I believe in test-driven development, because it leads to modular, robust code and enables safe refactoring
I believe in merciless refactoring, to continuously improve the design of software and banish code rot
I believe in design-by-contract, because well-done it complements automated developer tests and leads to more robust code
I believe in doing the simplest thing that will get the job done, because it's often enough -- premature optimization is the root of all kinds of evil (make it WORK, then make it better or faster)
I believe in automating builds, testing, and metric collection, because it's the only effective way to prevent regression of the code base and maximize the productivity of the developers
I believe in self-documenting code, because it forces small methods, short loops, and descriptive variable names, and discourages unnamed expressions and convoluted logic done to save a few keystrokes
I belief in documenting code with Doxygen, Javadoc, or other code-based documentation utility, especially at the method and interface level
I believe in learning something new every day, because you can never know too much
I believe two heads are better than one -- that teams produce better software than rockstars
I believe in aggressive multithreaded, distributed computing, because that's where the future of computing is headed

Education

Montana State University-Billings - BS Applied Mathematics

4.0 GPA (Summa Cum Laude)
Graduated with highest honors
Minor physics/computer science

Baylor College of Medicine

Graduate-level classes in Structural & Computational Biology & Molecular Biophysics

Publications

Cutting-Edge 3D Game Programming with C++ (Book)
3D Game Programming with C++ (Book)
Articles in C/C++ Users Group, Game Developer Magazine
Online curriculum for various classes and seminars at GameInstitute

Game Mathematics
Math Primer
Adaptable Artificial Intelligence
Perlin Noise

Projects

This is the section where I would normally list my employment history. Only technically speaking, I've only had one employer -- a job that lasted a mere two years of the 15 I have been working (I had to quit because I was leaving the area). I've managed to fill the other long years of my life with one contract job after another.

Contract work is rough. You have to look for jobs, and when you find them, you're given only a thick stack of paper written by lawyers and a hazy and often shifting target. You're responsible for producing the end product, using your own time and resources; for researching and purchasing the tools you need; for learning whatever you need to accomplish the job; and for doing it all in a fixed amount of time, on a fixed budget.

Writing this section is a bit like eating at an Indian buffet; I never quite know when to stop. I've done more than a hundred contract jobs, some so short they took only hours, others so long they took more than a year. Here are some of the highlights, for your viewing pleasure.

Collaborative Development Environment

This Java-based project involved developing a networked collaborative development environment for software engineers. I was lead architect and engineer, directing a team of 2-5 developers (it varied over the course of the project). The project required both client and server components, each of which were massively threaded. The server was backed by a pluggable database engine, and was concurrently accessed by PHP order fulfillment code.

Highlights

Developing a robust, high-performance asynchronous messaging framework over TCP/IP sockets
Developing a framework for asynchronous computing, which involved inventing novel threading concepts such as the 'permit' and the 'raincheck'
Developing novel methods of unit testing multithreaded code
Developing and implementing a novel algorithm for server-less, multi-user, lock-free, real-time collaborative editing
Developing novel genetic algorithm for computing file diffs
Developing a server-less, distributed, network-based locking mechanism to prevent race conditions in clients accessing shared resources
Organizing and managing a team spread across the globe, over a period of 2 years
Implementing a build & test automation framework

Lowlights

Discovering race condition-related defects, despite strong unit testing
Finding bugs in core Java 5 classes, due to the extremely stressful nature of the application

Software in the Electronic Design Automation Industry

This C-based project involved working on an existing behemoth application -- sometimes adding new features, but mainly debugging existing code. The application was multithreaded and distributed across 20+ processors, and optimized for performance.

Highlights

Working on a project with more than 20 team members
Working on a project with 3 million lines of code, written over the span of two decades
Developing simultaneously for Unix, Linux, and Solaris
Object-oriented programming in C (achieved through use of COM)
Developing and partially implementing a new way of reading data, up to twice as fast
Developing an algorithm for extremely compact hierarchy representation
Developing an algorithm for atomic, invertible hierarchy transformations
Introduction of iterator framework, design-by-contract, logging, documentation; and extensive refactoring, to improve the state of the code

Lowlights

The 'two week bug', which occurred in a gigabyte-sized dataset; attempts to isolate the bug caused it to disappear
Dealing with a tangled mass of C code more hacked than engineered, including a 10 page while loop, meaningless variable names, and assorted unspeakable abominations

Density Reconstruction

This pair of C++-based projects involved writing programs to perform multiprocessor density reconstruction of viral capsids and other symmetrical biomolecules from micrographs gleaned from cryo-electron microscopes.

Highlights	Heavy use of advanced mathematics, especially image processing and Fourier, Fourier-Bessel, radon, and wavelet transformations Use of MPI for distribution of computing task across 2-100 processors Developing a novel method of storing reconstruction data that cut down on memory and requirements by a factor of 6 over best existing techniques Developing an incremental reconstruction algorithm
Lowlights	Dealing with quality-of-reconstruction issues Interfacing with Fortran-based libraries

Artificial Intelligence Engine

This C++-based project involved developing an artificial intelligence engine that would later power an artificial life simulator and an AI training seminar.

Highlights	Developing a novel state-based AI based on Markov chains, where transition probabilities are specified by polynomial-based functions of environmental 'sensors' Incorporating theory from genetic algorithms and biological reproduction Developing a novel training method
Lowlights	Difficulty testing genetic algorithms (no clear 'right' answer)

Fishing Game

This C++-based project involved developing a fishing simulation game for Windows, complete with a suite of development tools. The maps and artwork were developed separately, by the company contracting my services.

Highlights	Developing Windows-based graphically rich map editor and other tools to speed development Use of transparent-span compressed sprites for maximum performance No patches necessary after development complete (nearly unheard of in the game industry)
Lowlights	Use of processor speed dependent casting logic caused differing casting behavior on different machines

Context Switching Simulator

This C++-based project involved writing a simulator to test the performance characteristics of differing CPU context switching schemes.

Highlights	Gained appreciation and insight into low-level kernel development
Lowlights	Extreme difficulty in unit testing led to lengthy debugging cycle

3D Game Engine

This C++-based project involved developing a software-only 3D game engine from scratch, which included features such as perspective-correct texture mapping, Gouraud shading, collision detection, and sprites. The resulting engine was published with the book Cutting-Edge 3D Game Programming with C++.

Highlights	Heavy use of mathematics, especially linear algebra, vector and matrix math Coined the phrase 'frame coherence' and first to publish algorithms (novel) exploiting the phenomenon Developing a Z-buffer clear-reduction strategy to dramatically increase the speed of software-based Z-buffer clearing Sixteen when I did it
Lowlights	Inexplicable and erratic behavior ultimately traced to a subtle memory overwriting bug

Others

Backend for several e-commerce websites (mostly Java & SQL, some scripting), home video organization software, graphical engine for Quake map editing tool, artificial life simulator, home inspector software, Wolfeinstein 3D clone, zzzzz.......