A year in review

2015 has been a good year for me, both from a personal and professional stand point. Here's how my 2015 went down (I will mostly just touch on career / work stuff).

In late 2014 I decided to switch jobs so I could work on a single web application. I realized I enjoyed working on a single product far more than juggling multiple web projects and never really sinking my teeth into the domain of the business.

The first thing I'll touch on is process. I've always been into process and being efficient. I'm really happy when looking back at how I work now vs. the beginning of the year.

I started out by recommending we work with Trello to simply organize and track our work. It's pretty basic but we didn't really have anything in place at the time. I later moved things over to JIRA and started implementing SCRUM. This was a game changer for me. I'm by no means an agile coach, but after reading up about it and watching a few video courses I was able to get a basic version of SCRUM in place. I started seeing the benefits very soon after that.

Another great win was introducing pull requests and code reviews into our process. The code quality was noticeably better and overall less bugs were found on production. Who'd have thought! We also went as far as standardizing the pull request format, which helped with putting together release notes. Lastly, we started using Slack for company-wide communication and its integrations. We use the JIRA integration to push the issue collector directly into one of our channels. workflow++;

Meetups

Another thing that stood out to me this year is my growing involvement in the tech community. There isn't much of a tech scene here in London, but it's slowly getting better. A new meetup started and I got to see some pretty great people give some solid talks. I got to see Adam Wathan talk about testing and also Chris Hartjes aka The Grumpy Programmer talk about his career. To top that all off I gave my very first talk at the same meetup. My talk was titled Exploring MicroServices, which was basically a summary of what I had come across after a couple months of researching the topic. This brings me to my next topic, the old and the new.

I've spent my last year working on an old-ish PHP app that has seen a few too many... let's just say it resembled the Big ball of mud pattern. For those who are not familiar with this pattern, here is what Wikipedia has to say about it:

A big ball of mud is a software system that lacks a perceivable architecture. Although undesirable from a software engineering point of view, such systems are common in practice due to business pressures, developer turnover and code entropy. They are a type of design anti-pattern.

But this is nothing new to me as I've witnessed this pattern basically everywhere I've worked. While working on improving the performance of the system and the overall cleanliness of the code, I've learned a lot. I've learned a tonne about what makes slow code slow. I've become better at debugging and identifying bugs, and have become very much aware of the code I write myself and how it to will be maintained by other people eventually. This is not something you get to experience when jumping from one project to another. Typically, you jump in, do what you need to do, and move on to the next. With this project, you have one code base, and this code base is the only one you get to work on. What you write or don't clean up will only come back to haunt you (or whoever else is on your team).

While working on improving the current software, we were expecting to see an increase of traffic. Many discussions were had about what we could do to better the performance. We talked about doing a re-write, or slowly building microservices around the current system and then eventually strangling the existing system. We talked about rebuilding another monolith to remove the need to pay down the technical debt that had been created. The conclusion was... how about I write about that later. All together, the discussions have been interesting, and as frustrating as it was, I'm glad it took this long. It allowed me to look at it from every angle and then some.

Let's switch gears. Another thing which deserves to be mentioned about this year is the reducing of the bus factor. This year I had to onboard 3 new people to a project that lacked in documentation. Overall, the project was hard to get into for new team members. With the help of the team, we put together some guides so others could perform certain tasks in each others' absence. Some of the things that helped were: moving all the passwords into one safe place, a small shell script I wrote to deploy to our staging server, and some how-to guides for some odd things. The code reviews have also helped this effort tremendously. I am also working towards BDD to help take this even further.

Side Projects

This year was a decent one for side projects. I rebuilt one of my pet projects with the help of my good friend Max. We tackled rebuilding talkboxes which was originally built in PHP around 2013 / 2014. I wanted to experiment with react.js and node, so we did. We had a solid month or so of on and off development before it started to fizz out. Here's what we managed to put together.

After that I explored Java and the Spring framework. The biggest challenge to me was getting used to the amount of configuration that was needed. Some of the concepts were easier to pick up than others, for example: dependancy management with Maven was not as foreign as it might be to a new java developer. The idea of Maven is similar to Composer or npm which I was already comfortable with. I found that a lot of the resources out there assume you already know everything about java. This made troubleshooting hard and frustrating. On the bright side, I learned that the java eco system is quite strong and has lots to offer once you know how to leverage it. I see why it's seen as an enterprise language.

This next item is a little less on the technical side, but is something I'm quite happy with. My hosting expired back in October and I decided to keep it simple and set up a Jekyll site and host it on Github. I have wanted to start writing for some time now and even had a few failed attempts. So now hopefully I will keep this new site updated in the coming year.

The tail end of the year was spent looking into Ember and Laravel. Ember is an incredible front end framework and its whole focus on convention over configuration is awesome. I really enjoyed playing around with it and learning how it worked. I also picked up Larval again and started working through some more Laracast videos. I've been liking all the advancements the frameworks made in 5.1 and 5.2, which is days away from being released.

Plans for 2016

I wanted to go into the new year with a plan, as it seems like weeks turn in to months and then another year is gone. I haven't yet decided what I want to do, but here are some of my ideas so far:

  • Work on getting a solid grasp on TDD
  • 52 weeks of vim
  • Make a list of 12 tech books and try and read them all
  • Write code everyday (Get my public contributions chart on Github all green)

So there you have it. What did you do this year? What do you plan on doing with 2016? Hit me up on Twitter or leave a comment.