I'm passionate about crafting code that solves the problem in a way that's easily extensible and easy to understand. Here, you can learn a little more about my philosophy toward writing code and the technologies I'm familiar with.
Since beginning my programming career in 2020, I've had the pleasure of working with a variety of technologies.
I have worked extensively with Typescript, sometimes using React, sometimes using Angular (including an in depth refactor and update from AngularJS into Angular 12).
I have worked with Kotlin, using Spring Boot and building with Gradle, to run a suite of back end microservices.
I used Tekton CI/CD to deploy to both PCF and GCP, managing both front end and back end deployments on these platforms. I also have some experience with Jenkins.
The variety of technologies employed gives me a broad base to adapt to any new technology, and a sense of what is or should be possible, even when faced with a new technology where I haven't yet used those features.
My coding philosophy centers around the art of refactoring. I firmly believe that well-structured code is a key element of any successful project. I'm constantly seeking ways to make code cleaner, more efficient, and easier to maintain. I love to dive into content that explores best practices, and share my insights in my articles.
This site is an example of my work. It's built with the latest version of NextJS (using the new App Router design), React, and MDX, in TypeScript. The basic setup is available for use by anyone as a template on GitHub.
According to Robert C. Martin (creator of the Agile Manifesto and author of Clean Code), developers spend about 10x as much time reading code as we do writing it. This suggests that the more clear the code is, the easier it is to understand. And of course, the better we can understand the code, the less time it takes to make requested changes. Code that is deeply nested, or full of branching logic paths, requires the programmer to hold more information in their mind at once in order to understand the line they are looking at. By using the appropriate abstractions, clear naming, and the tools the language has available to separate concerns, code can be written in a way that minimizes needing to keep a lot of information in mind at once.
Test Driven Development
The level of code confidence obtained by Test Driven Development (TDD) is invaluable. Strict TDD, which follows the flow of first writing a test, then making the test past, then refactoring the code (commonly referred to as
red, green, refactor), ensures that the programmer's assumptions the function of the code have been validated. Every line of code, every feature or function or piece of logic, are backed by tests that ensure they function as expected. This not only guarantees that software works correctly but also provides a safety net that allows for fearless refactoring. A programmer can work in the codebase without being concerned about unknowingly breaking existing functionality. TDD fosters a sense of security, knowing that your code is robust, maintainable, and adaptable to evolving requirements. This level of confidence is key to delivering software that stands the test of time and is readily adaptable to the changing needs of your business.