interested in hiring me as a contractor, or just want to have a chat to learn more?
say hello at tannerwelsh@gmail.com
services
- web application development
- software architecture consulting
- product design & planning
experience
i’ve been writing programs and building websites for over 10 years.
in that time, i’ve experienced all the joys (and pains) of working with languages like ruby, javascript, php, and python; worked on projects ranging in size and complexity from little toy scripts to cms-backed company websites to a yc-funded data gathering and analytics product.
i have also taught hundreds of people how to build with code, and have written curricula that has reached thousands more.
standards
for me, coding is a practice i take great pride in and one in which i am always looking to improve. i believe strongly in the benefits of discussing, establishing, and maintaining standards of quality for any project.
when i think about code quality, i am influenced by many greater minds than my own. i draw inspiration from principles like the 12-factor app, solid, and the patterns of object-oriented as well as functional programming.
in practice, the standards that i apply and uphold can be distilled and summarized as:
keep it clean.
this is a very simple principle, but it makes a giant difference. clean code does not have cruft or useless parts. clean code is formatted beautifully and consistently. it strives to reduce the cognitive load of anyone reading. clean code is like good design - it is invisible. we know when we see unclean code; clean code sits quietly in the background and lets us focus on what matters.
reduce complexity.
much easier said than done. complexity cannot be avoided - computers are intrinsically and immensely complex.
reducing complexity, for me, means utilizing patterns and practices to organize and structure code such that its functions at various levels of abstraction can be clearly expressed and understood.
in practice, this means doing things like keeping functions small and single-purpose. it means being diligent about a keeping a file and directory structure that works in harmony with the architectural structure of the code. these and other practices can keep code as simple as practicable.
write thoughtfully (for other humans).
code changes as a project grows, and the speed and facility of these changes are directly proportional to how well the people working with code can read and understand it.
“writing thoughtfully” means deliberately naming files, modules, functions, and variables. when we write thoughtfully, we internalize the perspectives of other coders and aim to organize our code so that they may be able to reason with and use it easily and smoothly.
leave a big trace.
when hiking in the wilderness, we always “leave no trace”. when working with code, we should do the opposite. “leave a big trace” means thinking of your version control history as documentation.
it means cross-referencing and cross-linking issues, stories, and specs with related commits and pull requests. it means recognizing that design intent should be explicit and easy to find.
test and refactor (whenever feasible).
in a perfect world, every bit of code would be fully covered by tests and refactored down to its most beautiful, elegant form.
however, most projects operate in a real world of limited time, money, and other resources. in the end, building a product that delivers real value is always going to be a higher priority than writing a full suite of tests.
with this prioritization in mind, i strive to write tests and refactor as much as possible, starting with the most critical and non-trivial parts of the codebase.