Taylor Venable's Resume

I hold a Bachelor's of Science in Computer Science from Purdue University, and am currently employed by TrustBearer Labs in Fort Wayne, Indiana, United States. At TrustBearer I specialize in writing server-side technologies to ease integration and management of web-based applications driven by multi-factor authentication systems. At work I'm quite proficient in server-side Java and AJAX web applications. For my own personal interests, I focus on the implementations of programming languages and operating systems, with a special love also for data-structure algorithms. My experience in a wide variety of programming languages across multiple major paradigms allows me to apply uncommon but successful approaches to otherwise difficult development problems.

I am not currently seeking employment, but my resume is still available in PDF format.

Professional Programming Philosophy

Putting together a worthwhile product in any environment requires discipline. Businesses cannot continue to produce fragile, arcane, and "eternal beta" software. This kind of software is not worth the money that was invested in its creation. Instead, we as software engineers in general need to enhance our designs to build software that is:

Robust

Over the years, programming languages have constantly invented new features to save programmers from overlooking sources of program failures: type systems and exceptions spring immediately to mind. But while these eliminate some common mistakes, many others which are sometimes impossible to catch (integer overflow is a good example) go uncaught until runtime. It is extremely important to write fault-tolerant systems that can recover when something bad occurs, because no matter how closely you check, the "impossible" will eventually happen. When it does, the software must clean up any unintended consequences and start over from the last reliably consistent state.

Simple

The problems that we typically solve are inherently complex, especially when large systems are involved. Overwhelming complexity leads to wasted energy during development and adds flaws to the result. Software engineering has developed a variety of ways to combat this, but it is the simplest of these which can count for the most. We need to adopt a set of "best practices" for each project, vowing to conform to certain styles of coding (variable names, data structures, control flow, etc.) and most importantly to document everything from function calls to component design. Documentation should be reviewed regularly, and must not be allowed to slip out of synch with the implementation it describes.

Evolutionary

Like all life on Earth, the quiet secret to success is slow evolution. Software cannot leap ahead in bounds without absorbing the consequences of sudden new bugs. But it's easy, especially when developing for the web where deployment is a few keystrokes away, to release whatever is currently available. This is convenient and new features are always being added, but older features are never being developed and allowed to mature. Quality software is tried over an extended period, with ownership and pride being taken in the fact that the victory of every new feature is built on the attestations of countless historic ones.

These are the principles I try to pursue in my own programming. The best code that I've ever written is able to pass the most ruthless testing, but is simple enough to easily explain to somebody who has never seen it before. This success is built upon the idea of evolving software from one correct state to the next. Software that "mostly works" is no longer good enough for our industry, and as a programmer I make it my objective to utilise methods which are resilient, clear, and steady.