Behind The Scenes @ Coolblue

So, now that the dust has settled and I’ve got some other commitments out of the road I can write a bit about the Behind The Scenes event that we host at Coolblue a few weeks back.

Originally the event was planned for December last year (2016) and I was approached to see if I would like to speak on a topic for the Behind the Scenes. A colleague of mine Pat was going to be the other speaker so we got together to see if we could thrash out a common theme to our talks.

Pat was keen to talk about some of the new tech angles we are using at Coolblue around logging and also been quite the thrillseeker (in my opinion!) was going to do some live coding demos as well. With the topic in mind, ELK stack and Serilog / structured logging it was easy for me to come up with a talk that matched.

People that have worked with me over the previous years know that I have a particular penchant for TDD and refactoring legacy software, and those that have worked with me since I found the book “The Mikado Method” around the end of 2014 will also know how passionate I am about applying the method and encouraging / mentoring anyone else who is keen to give it a go.

So what was my topic? Well, given that the original push for ELK stack and structured logging with Serilog came from a number of awesome people at Coolblue, I figured a talk on how the team I have been working with for the last 4-5 months used the Mikeado Method to refactor an application from using Log4Net with email appenders to using Serilog via Redis so logs could be viewed in our ELK stack.

The details of how we prepare for a Coolblue Behind The Scenes talk can be found on Pat’s excellent blog post here.

My slides for the talk that I gave after Pat’s can be found here.

The slides by themselves are not that enlightening, so I also managed to record the video for my talk (originally we were going to record both talks but technical due to gremlins in the works unfortunately Pat missed out). Once I have the green light that I can share the recording I’ll make that available to those that have asked for it.

In the upcoming weeks (or when I get a roundtooit) I am hoping to have a blog post written up for the very large refactoring undertaking that has been going on within the current team I’m embedded in. This involved taking an existing solution with tangled dependencies and code with some hard to reason about pieces and using the Mikado method over a number of sprints (still on going) to move the solution architecture to a hexagonal implementation, namely Ports and Adaptors.

I’ve used Ports and Adapters on a number of projects and it never fails to succeed in making it obvious for developers to figure out where infrastructure code goes (adapters) how it gets used in the domain (ports) and most importantly, where the interfaces live (domain) to ensure that the dependencies / references are pointing in the right direction.

Something I find lacking is some good reference  / template examples of how people have implemented their adapters and then wired them into their application so I also hope to come up with a small repo on git that demonstrates some of the patterns I’ve found to be useful when implementing this architectural style.

Advertisements
Posted in Article

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: