Everybody likes options!

Who doesn’t?

In our day-to-day life, whenever you have to take a decision, you almost always have lots of options. If your goal is to go somewhere, if it’s near from where you are and if it’s sunny outside, you can go for a walk or by bicycle. If it’s rainy, you can pick up your car or take public transportation. If it’s far away, then you’ll have to book a train or a plane. Now your goal becomes booking a ticket and you still have tons of options! You don’t have too much money? Go with low cost companies! You still want to reduce the price? Well, do not put any luggage in the plane’s hold and take only your backpack. Then you can choose the flying class: economy, first, business, … you can choose whether to use your miles or any other loyalty card, choose between different flight schedule, even choose where you want to sit! And it’s almost the same for the train! Everything is up to you!

The same goes when your goal is simply to eat! You’re lazy? Go at the restaurant! What restaurant? You have tons of options: fast food, Asian food, Italian food, … unless you live somewhere where there’s no restaurant at all, then the only options you have stand in your fridge! But when you’re at the restaurant, have a look at the menu: you see all the options?


Whenever you have a goal, something to accomplish, you always think about all the possible ways to reach it. And if for any reason the option you did choose doesn’t work, well, you simply pick up the next one on the list.

We love to have all those options; we love to be able to pick up the one that fits to our need.

So why the hell, don’t we have such options when it comes to software development?

I don’t speak about the way you will implement something, I don’t speak about the technical decisions here. You might have some technical options in mind depending on what needs to be done (unless there’s an enterprise architect in the way…) I Speak about how to reach a business goal.

Worst-case scenario: you only have specifications that tell you what to do. In this nice MS Word document where everything is written in advance, you don’t need to search for options: you won’t find a single one. Just do it like it’s described, the choice have already been made. Even if you’d like to do something else, you cannot, simply because you don’t know the business goal to reach and what are the measurements to check to know if you succeed. Just shut up and code! :-)

At best, you have a user story:

As a Customer, I want a brand new Refer A Friend page so that I can invite my friends to join and receive a 10% discount

Actually, the real customer need behind this user story might tell you another story instead:

We really need to increase the number of our customers because if we don’t then we might be in big trouble pretty soon.

The thing is that the user story doesn’t tell you that.

Creating a “Refer A Friend” page is just an option amongst others to gain more customers. It’s no more than an assumption that this option will do the job. It has been chosen upfront by some business people. But what if they’d have asked you? Would you have chosen to create a “Refer A Friend” page or something different? At least I guess you would have brought some other options on the table.

It seems obvious but you cannot have options without knowing the goal to reach.

So to answer my own question: we don’t have options when it comes to software development just because we often don’t know the real goal behind a user story or some piece of specifications. We don’t know what really is the customer need we’re trying to fulfill when developing a new feature.

Usually, what is written is specifications or described in user stories is not a goal; it’s just a way to reach a goal, it’s just a single option an assumption that it will work.

Think about how things would go if military ground troops would act like developers. They’d receive their orders as specifications from the military command saying exactly what to do. A nice and clear step-by-step procedure, written a couple of months before the d-day in order to guide them once on the field. Just like a poor developer they would only have one way to succeed in hand, just a single option. But in the meantime things have changed. Once on the ground the troops got quickly caught in a trap. It’s not their fault, though: it was not written in the specs!


Military do the contrary instead: they mainly receive the goal to reach from the commanders. They might have some options to start with, but it’s also up to them to bring some new ones as the mission evolves. The commanders trust the troops! They know that they were trained to react and adapt the right way as things change.

To solve this problem in software development, well, there’s no secret: you’ll need to bridge the communication gap between business stakeholders and dev teams. Communication and trust are key to success.

If business wants to keep up with specifications, why not suggest going a bit further with Gojko Adzic‘s Specifications by example.  This will help you to to cooperatively define the specifications based on real examples.

If you’re tied to user stories, then they should definitely sound like business goal instead of solution ideas (which is often the case). One simple way would be to find out two options that bring the same benefit. But an easier way would be to look into impact mapping where stories are not considered as commitments but options!


© Özlem Yüce from “How to train your HIPPO”

But the best thing to do might be to follow Jeff Patton‘s advice:

We don’t need an accurate document, we need a shared understanding

Discovering things collaboratively using Jeff’s User Story Mapping or Alberto Brandolini‘s Event Storming might be the best way to find options. Working together with business people will obviously let you know the real customer goal to reach.

Now take your shovel and dig up some options!

You’re brilliant? Stay humble!

In France there’s a humorist who was really brilliant. He used to make everyone laugh while treating hot topics like religion, racism and such other hard-to-joke-with things. He was really smart. The way he was dealing with those near the edge themes was really impressive. This is really hard nowadays to be able to joke about those topics and he was doing it really well while condemning them and raising awareness.

But one day, for any reason, he crossed the line.

Everyone taught it was shocking on purpose; he was so smart that people taught he was only showing how much hate could be harmful! But he wasn’t… This feeling people had, thinking he was playing a role, only last a few months. Everyone understood that he was not that brilliant guy anymore.

He’s now banned from any TV show and many cities don’t even allow his to stand up in their theaters anymore.

But why am I speaking about that guy?

Well, it might be excessive but this story might be quite similar to things we experience in software development: Brilliant people don’t always deliver the right message.

I’m sure everyone knows someone brilliant. It might be your colleague, the one that writes code so fast and that knows everything. You know, the one that understands complex concepts faster than anyone and for whom everything seems so easy! Look around you, you see her/him, right? ;-)

It might also be someone you heard about. A book author or someone who invented something really powerful you use everyday at work or even someone who created a programming language on his own! Yes I’m speaking about all those brilliant few. The ones you almost don’t dare to speak to because you don’t want to ask stupid question and feel like an idiot!

Those brilliant people are so good at what they’re doing that if they state something than it might be the right thing to do!

But wait, what if it was not? What if those messages they were delivering were only good for people like them? Meaning they only apply to a few of us.

They are influencers. And being in that position, they ought to act accordingly. They must understand that delivering the wrong message could hurt a lot of people that don’t have the experience to argue against them. They will believe them, blindly.

When you have natural capabilities to understand quickly complex things or resolve difficult problems, do not feel like this is the case for everyone around you: it’s not.

A really well known brilliant guy did recently an anti Agile/Scrum talks that resonated with a lot of people. Because of who he is and because of what he has accomplished so far, he was considered as the messiah for many developers. But a majority of people who loved his talk forgot one important thing: this might be ok for him, but not for them!

This guy has obvious natural capabilities coupled with a lot of experience. But he forgot one important thing: brilliant people are also humble. Brilliant people are able to adapt their talk to the average level of the crowd. Brilliant people will teach others how to grow and improve themselves. Instead of thinking that because this is how they do this should also be everyone’s way; brilliant people know that things that might work for someone might not work for his neighbor; things often depend on the context.

The most important of all: Brilliant people do deliver the right message.

Eminent scientist, reputed programmer or even you, the one in the open space for whom everything is easy; if you want to be brilliant then try to be humble. Stop thinking that everyone is as smart as you are but do strive to help people around you become better.

The good enough software

A couple of days ago, I was having a coffee with one of my colleague and he told me that:

“Almost every time we’re asked to develop a new feature, we provide our project leader with 3 ways of doing it: the quick & dirty way, the way we’d do it if we’d have the time to and, finally, the one in the middle: the way that allows us to meet the deadline doing something acceptable. Most of the time the later is chosen.”


Even if he told me that he was not so happy with it, he also said that it’s how it is and that they did not have the choice if they wanted to meet the deadline :-(

This plague has a name: the good enough software.

Kevlin Henney has a nice definition for this, here it is:

The good enough in good enough software refers to intrinsic quality: defect management, code quality and performance are not prioritized or managed as critical qualities. Deadlines end up being the focus, starting with initial time to market. While such an approach can appear to pay benefits in the short term, such an approach makes little economic sense in the long run — accidental costs and delays arising from quality issues come to define the development rather than features. (from InfoQ)

As a developer you should not provide 3 different ways of doing things. You should not jeopardize your projects by lowering the level of quality you’d like to put into. It’s up to your project leader/manager to strive to reduce the number of functionalities instead, it’s part of their job and this is where negociation is encouraged! As a developer you should always focus on defect management, performance and craftsmanship the same way.

This is why worse is better.

Worse is better has been coined by Richard Gabriel and as stated on Wikipedia:

The idea is that quality does not necessarily increase with functionality. There is a point where less functionality (“worse”) is a preferable option (“better”) in terms of practicality and usability. Software that is limited, but simple to use, may be more appealing to the user and market than the reverse.

If you do care about this, and I know you do, but your management don’t, well, quit your job :-)

And while you’ll be doing job interviews, please ask people you’re gonna meet this simple question: Is code quality taken as a corporate asset? You’ll know if it’s worth applying for a job there!

Does your code speak business?

There are many books and manifestos or even books about those manifestos :-) the aim of which is to teach you how to be more efficient. They provide you with diverse recipes and tools to be more efficient as a person, as a developer but also as organizations.

All those writings also have another important thing in common; they all say that in order to be more efficient you constantly need to focus on delivering value or even steadily adding value.

I did a presentation during a Paris Software Craftsmanship Meetup, where I tried to define what exactly value is and the kind of things you could put in place (and things to avoid!) to bring it down to your code or even within your tests.

Here you go!

The Phoenix Project – 5 reasons why you should read it!

tl;dr: buy it here!  ;-)

#1: It’s well-written


#2: It’s real


#3: It’s unique


#4: It strikes home


#5: It’s not just limited to the finding


Get your copy!

DDD is not architecture

While reviewing some résumés last week, my eyes were caught by this guy writing:

  • I’ve recently been focused on migrating to a DDD architecture

And some lines further:

  • Architecture redesign: Solution shifted first to MVC then DDD, multi-layered architecture implementation.

Apparently this guy tried to do some MVC but seemed not to be happy with it, so he decided to shift to DDD. This technique must certainly come from a secret chapter of Eric EvansDomain-Driven Design book that only this guy knows about! ;-)

Unfortunately this is not the first time I hear and see people confusing architecture and DDD.

A couple of weeks ago I went to a meetup where someone proposed to do a DDD Kata. I was quite enthusiast to participate and I started to imagine that we were going to do some Event Storming. Well, I must admit that I was quickly disappointed seeing the guy starting the kata by opening his favorite IDE. His idea was to do some code refactoring using DDD principles. To tell you the truth I was quite curious to see how he would manage to do so! The kata was similar to the Guilded Rose one; there was a lot of unreadable legacy code that you had to refactor to be able, at the end, to add a new feature without breaking the whole stuff. The guy quickly stated things like “as DDD tells us, let’s extract some interfaces so that we can put their implementations in another layer” Ouch! It took them some time (and a few remarks made by a couple of attendees) to realize that they were not doing any DDD at all.

So why do people keep on confusing DDD and architecture?

What I find as being the most likely explanation is that it’s due to the presence of the “design” term in Domain-Driven Design. But as Grady Booch says “All architecture is design, but not all design is architecture”.

DDD is not a technology; it’s a set of principles that will help you to deal with the complexity of an application domain by modeling it. DDD is focused on the domain and its logic where “Software architecture introduces structure and guidelines into a software system, leading to consistency and clarity” to quote Simon Brown.

But keep in mind that principles do impact your software architecture. Going with DDD will obviously lead you to choose the software architecture that will welcome it warmly. Architecture styles like Hexagonal Architecture or Onion Architecture will definitely help you to accomplish that as it will isolate the domain and avoid the business logic to be tightly coupled with any infrastructure related technology.

Should you go with DDD? Well, as it’s often the case, it depends! From my point of view it mainly depends on your domain complexity: the more complex it is the more you might benefit from DDD. But every choice comes with a cost; it will be up to you to evaluate the need and as Simon Brown says: “Principles are good, but make sure they’re realistic and don’t have a negative impact”!

Buy cheaper books!


Every week plenty of interesting books are released.







Happy Reading!