S09E05: Title goes here

Three things:

  1. Advent of Code got really difficult, although at least partly because I’m forcing it to be difficult
  2. Work started to slow down, just as I started to get to grips with it
  3. I got some honest feedback that was the brutal reminder I needed to be more considerate

In reverse order:

I am really frustrated with myself that someone had to give me this feedback, because I’ve banged on about this endlessly myself. Senior people, I have written crossly on these very pages, should really think before they speak. They should remember that they’re senior people before they remember that they’re experts.

As with sex and food, good intentions are simply not enough. I fell a long way short of my intentions, stepping into someone else’s domain without proper consideration for the time they’d spent working on a problem. I jumped in already assuming that I knew more than they did, and with a pinch of wanting to prove that I could be valuable. I’m going to cut that out.

On the plus side, I’m so lucky that someone felt comfortable giving me that feedback. It shouldn’t be necessary, but at least I’ve had it, and now I can correct myself. So that’s good.


Work is starting to slow down for everyone, I think, because of the impending festivities. So emails are starting to bounce back from polite but firm out of offices (outs of office?). So out of a desire to write a little code, and to be useful, I’m covering a little information service. So far I’m not writing any backend code, but I am re-familiarising myself with GitHub Actions and the language we use to describe how we deploy code into a production environment. The language is called YAML, which stands for YAML Aint Markup Language. The first YAML stands for YAML Aint Markup Language. The first…

You get the picture. It’s recursive, which is a topic I covered last week and will likely cover again. In fact, it’s come up as I’ve been writing Python in a functional style. The other thing we insist on in functional programming is immutability: that things can’t change or be changed. You can create a copy, but that copy too can’t be changed. It forces you to think about things quite differently.

I’m finding myself applying that thought process to deploying code. The binary package that we deploy should ideally be immutable: nobody, even me as the developer, should be able to poke around inside it. If there’s a problem with it, we should fix the code once at source and then redeploy the binary. This is at odds with the traditional approach, which is caring for servers like they’re pets and jumping into them every so often to mess about with the environment or similar.

“Redeploy” is a weasel word here that actually covers a lot of work. The binary has to be properly tested, and once it’s tested, we want to promote it into a testing environment so people on our team can try their best to break it. From there, we want to promote exactly the same artefact into production. The slower we do this loop, the longer it takes to get changes into the hands of users.

This is why people like me obsess over small changes and automating tests as much as possible. This is what I’ll be working on over Christmas, I think.


Advent of Code got impossible this weekend, and it really killed my enthusiasm. I’m also finding I have less time? less desire? in these very dark evenings. Instead I’m just getting cosy with m’buddy Salem and drinking a lot of tea.

me and my feline buddy Salem having a cuddle

Maybe in January, eh.

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 )

Google photo

You are commenting using your Google 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 )

Connecting to %s