Employment History

Designbook & VENTURE.co

Lead Web Application Developer
Mar 2015 - Current

In early 2015 I joined Designbook and about a year later we re-branded as VENTURE.co. I was the company's first full-time software developer and I participated in the entire application development lifecycle; both front-end and back end, systems administration, DevOps, project planning, prioritization and guiding fellow developers. I oversaw many crucial projects that were critical to the success and running of VENTURE.co, many of which I detail below in Notable Professional Projects.


Wyatt Investment Research

Web Application Developer
Nov 2013 - Feb 2015

In winter of 2013 I joined Wyatt Investment Research where I helped lead the transition from a legacy CodeIgniter app to a new Ruby on Rails application. This entailed a challenging database migration as well as allowing the company to continue processing payments through a very challenging and tumultuous transition.


MedForce

Application Developer
Feb 2012 - Nov 2013

In early 2012 I joined MedForce where I oversaw the maintenance of many legacy applications. While I was there I cut my teeth on some pretty gnarly SQL statements and helped develop new features for clients. The custom implementation taught the importance of clean separation of concerns when building a complex web app.

Notable Professional projects

Mentored and guided team members

VENTURE.co

Easily the most significant contribution during my time at VENTURE.co was the ability to mentor and guide my fellow developers towards more understandable, simpler software solutions. By the time our current team was established I had been with the company for 2 years and developed a solid understanding of our business and the application stack that powered it. Being able to spread that business knowledge amongst the team and see that directly lead to more soundly designed code was incredibly gratifying... and productive for the company.

These interactions included code review, whiteboard designing sessions, sprint planning, debugging sessions, and, occasionally, an informal type of pair programming. Our team was distributed and these communications often involved a mixture of team members who were physically in the office and others who were remote; I would often split my time between the office and my home.


Secure PII Storage

VENTURE.co

In the world of private placements our engineering team was tasked with something that traditional tech advice guides you to not do; collect highly-sensitive Personally Identifiable Information. I'm talking about pieces of data like Social Security Numbers, Date of Births, Bank Account numbers, and other pieces of data you wouldn't want just anybody to get their hands on. We had outsourced this storage multiple times and due to many considerations it was decided the functionality needed to be brought in-house.

After reviewing secure storage possibilities we wound up choosing Hashicorp's Vault but we still needed a way to transparently store this data in Vault for both a Ruby and Java application. We wound up implementing a similar solution for both technologies. By hooking into the ORM's lifecycle listeners we were able to store the encrypted value in Vault while replacing the value inserted into the database with a token. Upon hydrating objects from the database we would conduct the opposite process and read in the value from Vault based on the stored token. This ensured that data at rest is stored in a secure, encrypted storage and reduced the possibility that if a database breach occurred that sensitive information would be lost.


Escrow abstraction layer

VENTURE.co

A really important part of handling private placements is dealing with escrow; the process of many investors paying money into an account where it is held for a time until it is either refunded to the investor or the sponsor of the raise receives the funds. One of our first solutions for this included a third-party provider that was bought-out shortly after our live release which necessitated reimplementing the escrow functionality virtually as soon as it went live.

With the next implementation I designed a system that would allow the basic functionality of escrow to take place within our application and domain while allowing "escrow processors" to be developed according to an "interface", or as close you can get in Ruby. This system proved invaluable in ensuring that we incurred minimal technical costs due to volatility with integrators in this space.


Chatbot and webhook system

VENTURE.co

When VENTURE.co was getting started we were a small team and were primarily focused on customer facing functionality. This left certain administrator functionality not as polished as we would have otherwise liked. One of the issues faced was simply knowing when investors performed certain actions within the system. To faclitate this, and other operations, I developed a chatbot that authenticated with our application through an Oauth 2 flow as well as a webhook system that would send data about events triggered on our system with a simple HTTP POST request. This system proved invaluable during our ramp-up period with ensuring that administrators were properly notified when actions happened within the system as well as other helpful information fetching activities.


Credit-card processing translation layer

Wyatt Investment Research

When I arrived at Wyatt Investment Research the company was transitioning their app to Ruby on Rails. During this transition there was a hard requirement, with a strict deadline that our current custom-implemented credit card processing be transitioned to a new provider so that customer payments could be received and employees could be paid. It was decided that the existing application was too untested and I did not possess the knowledge needed for that level of refactor. Instead, I implemented a layer that sat between our application and the new credit card processor that ensured the old batch payment format was properly translated into the new processor's expected format and that the response was translated into something the legay app could work with. This proved to be critical during the transition period to ensure that customer payments continued to be received.

Goals

To be successful in any endeavor you need to have achievable goals that pushes your progress forward; this is especially true with software development. Over the next 2-3 years I have the following technical goals to improve my ability as a developer.

#1. Continued growth as Sr. Developer

I am eager to continue maturing as a mentor and leader on software development teams. I find interacting with my peers rewarding and training developers on domain knowledge, design patterns, unit testing, and general software maintenance provides important business value. I am still young to the role and am in search of an environment with strong senior leadership that will help me mature as a leader.

#2. Continue building asynchronous PHP libraries

I believe that userland PHP provides a compelling set of functionality when you desire a single-threaded, asynchronous architecture. I've already written several libraries on top of Amp and have submitted some small contributions back upstream. I plan to continue designing and developing async libraries that, hopefully, become used by the asynchronous PHP community. I also plan to give at least 1 talk at a small meetup group about asynchronous PHP.

#3. Learn Go and/or Rust

These 2 languages especially have several compelling features to them and I believe learning them would be a valuable addition to my programming toolkit. Once I have identified possible personal projects that are well suited to either of these languages I plan on diving into them.

Personal projects & OSS Contributions

I have been active in the OSS community, either through creating my own projects or contributing back to the libraries I use in those projects, since I started my programming career. The projects below are some of those I have worked on fairly recently and represent my most recent thoughts on software development.

Labrador Kennel

I have been mildly infatuated with creating my own framework since I realized what frameworks were. While I would not necessarily recommend that people create their own framework I find it enjoyable and it has allowed me to learn a lot about programming that I can apply virtually any time that I'm designing a system. Labrador Kennel represents the 3rd generation of my own framework and is meant to be a suite of PHP libraries and packages that facilitate creating performant, secure applications using Amp.

yape

Yet Another PHP Enum. There are numerous examples of PHP libraries using class constants with scalar values as a type of pseudo-enum. However, I wanted something that could have type-safety, method calls, and generally to treat the concept of an enum as a first-class object in the PHP world. This library is a code generator that will create a type-safe, object-backed enum for you.

websocket-commands

I have recently been doing some development with real-time status updates and other functionality that is well-suited for websockets. I realized while building the app that the system for executing the commands based on the client's websocket messages could be its own micro-framework and shared with the community.

amphp/phpunit-util

Being a big fan of Test Driven Development it was important to me that my asynchronous apps and libraries be well tested. Testing asynchronous code has its own set of unique and interesting challenges relative to testing blocking code. With the help of the maintainers of the amphp project I was able to design and develop an AsyncTestCase implementation that greatly reduces the amount of boilerplate required for async testing and has become the de facto test case for asynchronous code within Amp.