Always be shipping

Building software is fun.

It’s great to develop something from nothing, or extend something to do more than it did before.

I think coders want to build things the best way they can. But in practice, that doesn’t always happen. Shortcuts can be taken, perhaps due to time pressures, or major requirements popping up late into a piece of work. Sometimes, you need to make changes to software that are quite different to what it was built for to begin with.

But software changes, and we can’t always anticipate how it’s going to change. In fact, we probably shouldn’t worry too much about how it might change in ways we simply don’t know about yet. (It’s a bit different if it’s your product, such as a hobby project, and you know some of what you’ll be adding later – and can build for those things accordingly.)

Perfect code

We shouldn’t be aiming for perfect code. Equally, we shouldn’t be happy with crappy code, but that’s not the point here.

Delivery – shipping a product or feature – is vital. It doesn’t matter how beautiful your code is if you never ship.

It definitely matters if you build a mess of a system that will be painful to work with in the future. But we shouldn’t be agonising over making everything perfect before anything is shipped.

I know there are developers who will find some of my code from years ago and say “what was he thinking?!” And to be honest, if I read it today I’d probably think something similar. I’m sure I could think of ways to improve the code I worked on back then that I didn’t think of at the time.

But the important thing is that the code shipped, we could monitor how things went in production, and we could get stuck into other projects.

Continuous improvement

Continuous improvement is a wonderful thing. Some of my favourite projects have been framework migrations. I’ve migrated from a proprietary framework to Zend v1; I’ve migrated from a basic home-grown set of PHP classes to an MVC framework; I’ve managed a migration from Drupal to Laravel. More recently, I’ve worked with a team who have been migrating from a FuelPHP monolith to a service-oriented architecture.

With large-scale migrations or any major refactoring, breaking off components of the application and migrating them piece by piece is an excellent way to minimise risk, keep momentum going, and avoid a seemingly infinite end date. The concept of “dropping” a massive new upgrade on a given date for an entire customer base is extremely risky, and runs the risk of being rolled back if it all goes pear-shaped.

Testing

There’s a phrase I have in my head at all times as a reminder of why “big bang” launches are so dangerous:

It is difficult to know when testing is complete.

Testing is not something you start and finish. Testing is an ongoing process, a discipline, that can incorporate a selection of the following at various times:

  • Automated unit tests
  • Automated integration tests
  • Manual exploratory tests
  • Manual functional tests
  • Manual or automated regression tests
  • Manual UI tests
  • Non-functional tests (a large category)

Testing helps to highlight everything from catastrophic failures to tiny UX quirks. But having tests doesn’t mean your big bang implementation will be fine – especially in a big, complex system.

Scrum

In Scrum, the output of a sprint is a potentially shippable product increment. Whether you ship or not is up to you. But the point is that you can ship if you want to. This capability should be available to the Product Owner.

When a development team thinks they have 6-12 months, or years, to deliver a project (or maybe there’s no end date at all), it’s can be very tricky to keep the team focused. Agile accepts that requirements change frequently. This in itself is not an instant issue. However, when you have a long-running project that isn’t shipping anything, and constantly changing requirements, especially when development is already in progress – that’s a recipe for disaster.

Always be shipping

There’s a lot of different things I’ve discussed in this post, but it boils down to one simple thing. Always be shipping.

Stop adding a day here and there to perfect something that already works fine (and has unit tests that pass).

Start getting stuff out the door.

Advertisements

How to minimise CRUD front-end code duplication in Laravel 5.4 / Twig

CRUD (Create/Read/Update/Delete) is something that developers do quite a bit of. Frameworks can help with this, but there’s still a fair amount of code you’ll need to write for every CRUD screen you put together.

One particular area is the difference between Create and Update. For many of the projects I’ve worked on, Create and Update are often very similar. They aren’t identical, but if there’s enough overlap between them, you can minimise duplicate code with the following setup.

Continue reading “How to minimise CRUD front-end code duplication in Laravel 5.4 / Twig”

Food photos taken before I went gluten-free

I’ve been browsing through some old photos, looking for things that I could post on my blog. In doing so, I’ve come across several food photos (and a couple of drink photos) that are of things I’ve had to give up – or at least change – since going gluten-free in late 2014.

Here are a few of my favourites – or the things I used to like, anyway…

Continue reading “Food photos taken before I went gluten-free”

Shooting album covers in Central Park, NYC

In late September/early October 2006, we went to New York for the first time – so far, the only time. We decided to visit New York while we lived in the UK, as we would be moving to Australia just a couple of weeks later – and the journey would be shorter from the UK.

We visited Central Park, and took photos as we went. Some of these were potential album covers. Here are a few from the shoot.

Continue reading “Shooting album covers in Central Park, NYC”

What is blogging in 2017?

Never mind the future of blogging – what’s the “now” of blogging in 2017?

I’ve been a bit quiet here recently. There are various reasons for this, but if I rolled off a few, they’d sound like excuses.

The quick version? Circumstances change. People change. People move on.

Ironically, I don’t always blog my thoughts in case someone reads something I’d rather they didn’t. By not blogging at all, I’ve certainly taken care of that.

The risk in 2017 (or 2015, or 2020) is that everything you say is so visible. So easy to find – and so hard to erase.

There’s that line for people who worry about their private messages being accessed. “If you’ve got nothing to hide, you’ll be fine.” I’ve become a bit paranoid – not because I’m plotting something, but because once you put something in writing, it could be held against you – somehow.

While there are loads of stories about how someone has said or done something terrible, I can’t help feeling that it’s all too easy for one bad comment to permanently tarnish your reputation. There are levels of severity here.

I guess the answer is to not put it in writing. It feels like we’re expected to do this all the time. A blog cannot be too personal, lest you reveal too much. We can’t post negative things online – unhappiness, un-constructive criticism, anger, moaning, venting – because that reflects badly on us.

Thus, we have these uber-positive social media profiles. No wonder the only thing I can remember seeing on Facebook is engagement, marriage, and babies. Occasionally birthdays and barbecues show up. Oh, and holiday photos. There’s not much else.

So, what’s the “now” of blogging in 2017? It feels like blogging – and online life in general – has become very filtered. Based on my own anecdotal evidence, the overwhelming trend for everything I’ve seen friends posting online is that it’s positive – or at least has a positive spin.

I’ve posted less, because I haven’t always had happy things to say. To be honest, I haven’t had much of anything to say. Facebook particularly seems to be geared towards sharing things when you have news – especially when it’s positive. This is perfectly illustrated by the lack of any reaction besides “like”, at least until February 2016. The “like” button “was first activated” in February 2009. That’s seven years of Facebook giving the indication that positive stuff is preferred.

We’re human beings. We’re not always going to be happy. Suppressing negative emotions by not sharing them is probably not a good thing. I’m sure someone else has said that better.

For now, blogging is filtered. Maybe it’s time to change that.