Code re-use can be as bad as code duplicate

Code duplicate is one of the top evils in software development. But as strange as it may sound, code re-use can be a pain in the eyes too. Let me explain.

Our team works on intermediary layers of the product. Yes, sometimes horizontal slices are the way to go. Our product is about monitoring. It’s made up of a home-made database, an intermediate layer that defines and computes analytics, a framework to define specific applications, and the applications built on top of the platform. Our team works on the analytics. The main thing here is that we build frameworks. It’s actually what I always did. The problem with frameworks is that you never can anticipate every use case. They are here to provide tools, not end-user features.

For this kind of code, BDD-like tools are difficult to apply. BDD needs you to know precisely enough what you’re going for when you commit on a backlog item. And it requires to come up with a limited set of features to test. With such technical code, though, you can hardly state the new required behaviors as user stories. And the main thing you want is the whole to remain stable and efficient. Before validating new features, you want to test non regression. After a while, it becomes difficult to test it manually. And automated tests are not perfect by nature: the more stuff to test you embed in the automated test, the less maintainable and fast the campaign will be. You thus make trade offs, which test is all about. You can hardly test a re-used tool correctly.

We can even get down another step. A piece of code that is re-used by a flip load of modules is a nightmare to maintain because we never really know how it’s used. Even if you run a set of unit (or automated in any way) tests you rightfully trust, you are not sure the piece of code is used the way you test. It’s particularly true for code that’s been here for a while: when an additional module uses your code, it’a miracle if the guy implementing the calling code thinks about adding the automated test that guarantees the called code does what he expects. And please allow me to look somewhere else with a strange face if you tell me that 100% code coverage guarantees your test base is nuclear bomb proof.

A few years ago, when we were having regression issues on our code base, I was surprized to realize we wouldn’t have such problems if we had not shared a particular piece of code. It hurt a basic rule I had believed in for years. And then I realized I was only experiencing the need to think about another trade-off we always need to balance: sustainability vs sustainability.


Perfection is a verb

Ok, this sentence sounds like a fortune cookie. Maybe I’m turning buddhist, but I love it. And it  applies especially well to software development. As a craft based on human interactions, software development is a set of compromises. There’s no such thing as a best practise, a definitive process, or a methodology that works for all contexts. I don’t even understand how words like agile and process or methodology can have ever been put together in any mind.

Agile and lean are approaches that work the best according to what we know today. But they are just containers of values and practises that constantly evolve. They don’t tell you what words to use in discussions, or what lines of code to write for every single situation. They need to be adapted to every context. Scrum and lean startup by the book might be good enough to design a simple shopping cart, but not necessarily to design a car, a distributed NoSQL database, or a nuclear plant software complying with all required regulations.

You always need more than what you can learn in trainings or books. Your situation is always unique and new. If it’s not new, why bother doing it? If you didn’t need to adapt the framework, why would scrum define the basic team around the opposite powers of dev, backlog, and test? Why would lean be based on kaizen in the first place? A set of definitive rules, a process, would be enough.

In the end, you always need to adapt the way you build, collaborate, understand each other, find solutions, analyze gaps, code… and to get better at it. Always. There’s no end to getting better. Because you can always be better, and because the context keeps evolving. And that’s what I love about it. You always can and must do better. Everytime you’re not trying to get better, you’re getting a bit closer to the death of your team, project, organization, company. The world won’t wait for you.

So perfection is the goal, but you can never reach it. How exciting! That’s what the best approaches known so far explain to us right from the beginning. You need to find the right compromise, for every situation: test coverage vs test campaign maintainability, code performance vs readability, taking the time to discuss and understand each other vs saving meetings, writing just enough documentation vs focusing on working software, self-organizing teams vs facilitating their progress, releasing features vs stabilizing the product… There are hundreds of parameters you need to balance. And you always need to tweak the buttons as the situation evolves.

In the next posts, I’ll try to talk a bit more about the tradeoffs we are faced with day by day. What the books don’t say, and the concrete problems they don’t give solutions to. I’ll try to describe the approach we’re taking to oil the wheels. I hope it will save me the shrink.

Estimating, what is it good for?

We just had a very interesting discussion about estimates. We started this discussion with re-assessing the weight of our story points, but it lead us to talking about why we need estimates.

I think the ideal goal of any framework or methodology, as for managers, is to disappear and lead to anarchy (but not chaos). Therefore, I look for any occasion to get rid of iterations, estimates, follow-up, or any other method or tool. I’d like to get to a minimum process focusing on communication, and then make it disappear as it becomes natural.

Estimates can be useful, but they are expensive. And we weren’t clear about where they were useful. So we tried to think out of the box, and rebooted our thinking about the reasons why we needed estimates.

In a recent post about transitioning to agile, Dean Stevens said:

[We can] explain some benefits of an Agile Transformation this way:

  • Business wants predictable and improved throughput.
  • Customers want quick lead times for quality product.
  • Teams want a good working environment where they can contribute and succeed.

I thought the ultimate goal of estimating was to come up with a long term planning (few months) with some confidence. From my experience, customers demand some planning for their requirements.

But I was explained that getting to that end to sell something was a commercial failure. Long term planning is never reliable. It is not when it comes from the provider, and it is not when it comes from the customer! I know you rarely deliver exactly what you planned a few months ago. And does your customer still exactly needs what he requested 6 months ago? Is he still ready to use it now that you’re delivering him?

Negotiating such plannings in a precise way is a poker game, where everybody looses.

You can still have a high level long term planning, but be clear on the fact that it is nothing more than an unclear wish-list based on the knowledge you have today. Don’t constrain your development process for this objective. Manage long-term planning outside of the development process, using tools like portfolio management or epic/theme backlog, where you estimate your epic/themes in comparison with other [done] epic/themes, and not development items like user stories.

The agile community agrees on the use of the discussion around estimates. I totally agree with it. Estimating is a great way to make sure we have a discussion. It’s a great way to detect comprehension gaps between team members (devs, qa, business,…). It also allows devs to agree on smaller chunks of the story (tasks) to run in parallel in order to swarm. By having this discussion, and the objective of a consensus around estimates, we have a better chance to align our comprehension of the why, the what, and the how.

But estimating is only one way to get there. We could get to the same point with a different objective, like colorful or timely drawings, a list or a number of tests, mock-ups,… So again, if the goal of the estimate is only the discussion, if it’s a game among others to run during the iteration planning, we should not make the rest of the process heavier for it.

What about the process? Through estimates, you get a  throughput. By making this throughput predictable, you make the process and the backlog predictable. By optimizing your throughput, you optimize your whole process. By detecting deviations in the throughput, you detect exceptions to your standard process (i.e. deviant deviations), and thus optimize it. And so on…

But there are other ways, like following up the cycle time, the WIP, and thus bottlenecks. You can monitor your throughput as a number of items, and not a number or story points. If your items are within a reasonable size, the standard deviation of your throughput and cycle time should be acceptable (compared to estimating error or your constraints). Agreeing whether an item is of a “reasonable size” is estimating. But I believe it is a lot lighter than formal methods like planning poker.

It leaves us to the short-term planning. Estimates are useful to know what you’ll do in the next few weeks. Like for long-term planning, I’m not clear on the goal of this. Making sure you respect due dates is definitely a fair objective. Motivating teams with an objective to reach is another one. Prioritizing considering constraints and slack is also important. Having a prioritized backlog where teams can pull work without bothering a PO is great. Fine, we’ll suppose you need to know what you’ll be able to produce in the next few weeks. And drum roll…

BUT is estimating useful to have a prioritized development backlog and a short-term planning? It is if your throughput and cycle time standard deviations are too important. If they are, you need to sort your items by categories where these standard deviations are acceptable.

As a conclusion, what you need is buckets where cycle time and bandwidth occupation are close enough for all items. If you only have one bucket, it’s perfect. If you have more than 4 or 5 buckets, you should really think about it. Estimating is knowing which bucket fits your item, or splitting an item so that all sub-items can fit one of your buckets.

For different levels of plannings, you can have different buckets. For example, you may have development buckets for the development backlog, and release buckets for the long-term backlog. Those buckets are not of the same nature. Neither are the items they contain. Don’t try to fit development items in long-term backlogs, or long-term items (epics/themes) in the development backlog, without further analysis.

As a conclusion conclusion, monitor your throughput, your cycle times, and their standard deviations, identify your buckets, and make them the least possible.

What do you think?

My stories are too small

We want to have backlog items that are as small as possible. It protects us from the unknown. It prevents us from having to re-work too much code if rejected, and limits the effect of wrong estimates. It allows us to be predictable.

In the same time, backlog items must have a meaning. We want to be able to release something valuable. Done-done also means useful. If it’s not, how can you adapt your backlog to actual needs? What’s the value of your high-level estimates? If something considered as done is in fact half-done, how can you release it? Splitting stories also means you can stop at the end of the first part.

I’ve never found the right recipe. And I just bumped into this situation again. The need is something like “I want to use an object of type A in screen B”. To use this object, I must first select it, so I need a selection screen. Then I need a select button that actually allows to update screen B given the object selected. The thing is… just implementing the selection screen doesn’t fit in the iteration.

Note: we are in an iterative mode but the issue would have been the same with a flow. The story is too big, and we couldn’t split it.

Only implementing the selection screen doesn’t make any sense. If we had to release at the end of the iteration, the user would have a selection screen with a disabled select button that says “to be continued”.

We chose the smallest issue: split it and deliver something that is not usable or useful at the end of iteration, but deliver something anyway. We prefer feedback than nothing, partial waste than entirely in stock. But still I’m not satisfied, like always in this situation. And finally we have this ugly story: “I want to use an object of type A in screen B, part 1”. So…

Feedback is warmly welcome. Have you encountered this situation? What do you suggest?

As an employee and a developer, I don’t want to

Work with a direct manager (or sole decision maker) I never see.

Follow a plan that is not adapted [anymore], because stakeholders agreed on it.

Work on a project that is never validated against reality (users, actual needs, integration, deployment, tests…).

Spend lots of time writing or maintaining doc that is never read, will become irrelevant as soon as it’s written, or duplicates existing information like the code.

Face impediments that are never removed… ever.

Work for a company that doesn’t allow to take any micro decision because:

  • Of blaming.
  • It doesn’t have other goals than “increase money”, thus no direction regarding the actual work.
  • Mistakes are not allowed.

Spend hours in meetings managing problems I would have solved by working.

Spend hours in meetings sharing, or providing tools with, information that is already publicly available, or data that could be directly derived from it.

Put hands back on code I left days ago because of bugs/regressions.

Work on a born-dead project, because it was budgeted 18 months ago, or because it was budgeted even earlier and budgets are based on history.

Not having resources that would save us money, because it’s managed by another department which sole objective is to minimize its budget (e.g. IT).

Work for a company that encourages fire-fighting instead of anticipating problems.

Be slowed down by the organization I work for.

Optimize things that don’t get in the way.

Work for a company that manages human resources.

Hear that a decision that gets in the way is strategic/the rule.

Not have a dream to make come true with my company.

As a human being, I want to have the opportunity to succeed, and make it happen.

Coding dojo – a great team builder

Lately another team organized a coding dojo. The feedback was great.

The idea of a dojo is quite simple. You set an objective for about 1h of dev (games are cool). You begin with a pair of developers. All others must be able to see them and what they do (e.g. using a projector). Developers are asked to say what they’re doing, and apply pratices like TDD. The navigator should also do his job, of course. Every 5 minuts approximately, the pair changes: the pilot leaves, the navigator becomes pilot, and someone else comes in as the navigator.

Just looks like a game, right? But it is helpful for many aspects, not only for technical stuff. In this team particularly, most of the devs attending the dojos were not very experienced in software engineering and agile. Of course, they learned technical things from their peers, like:

  • patterns
  • IDE features and shortcuts
  • coding technics
  • refactoring technics

As everybody could experiment these in a safe environment and witness their benefits, it was also a great way to foster XP practices like:

  • pair programming
  • unit test first
  • always refactor

And last but not least, most feedbacks were, quite surprizingly, also about observing how the team interacted:

  • what devs knew or not
  • how they analyzed problems or found solutions
  • how they interacted with their pilot/co-pilot

I was surprized about the outcome of this experiment… not because it didn’t meet my expectations, but because it went way further.

Thinking about it, the coding dojo is close to the optimal compromise between safety and realism for software engineering. You can try new things, observe their benefits, observe your teammates. You can do it without bad consequences but with hands on, in a very short but effective time. I will definitely use it for passing dev messages.

Has anyone tried coding dojo before? Do you have any feedback about it?

Open source mindset to enable scaling

In order to scale agile, we need to bring several teams on the same page. We need them to share a business and user understanding, a vocabulary, pace, backlog, and emerging architecture. Teams must balance functionalities and architecture, business value and quality, across a common project.

When the number of teams increases, we often end up with teams more specialized on technical components than others. If we don’t, we sometimes have more issues getting a consensus from all teams about what needs to be done how on very sensitive pieces of code. At the end of the day, even if the agile manifesto discourages silos, software engineering is still a craft, and people are better at some stuff than others. The agile manifesto also encourages small teams, so you need to have some kind of borders between them.

So we might create silos… not a good idea. But projects already do it out there, and have success doing it. Have a look at open source projects that do very technical stuff about security, message queuers, databases, servers, and so on. They make components that are far from the final features delivered by projects that integrate them. Only a few people have a final word on what is developed. But in the end, they provide what integrators expect from them, and generally respond quickly enough to requests. You can reliably integrate them in order to provide features. And they build quality. Why does this work?

Because everything is transparent. They have wikis, tutorials, forums, jiras, githubs, they interact with their users, respond to requests, take suggestions into account, and make decisions and roadmaps clear to everyone. You can even get and debug the code, fix it, propose new features implementations, so that they are included in the next release. At the end of day, if the component is useful to the community, a team of a few people have proposals from dozens or hundreds of people.

Now let’s get back to our in-house multi-team project. As input, you have a business backlog. You refine requirements, split them across teams. When assigning them, you come up with direct requirements for core components. While teams study functional requirements (or develop them), they will also come up with requests for core components. At this point, you have 2 solutions:

  • either all teams can modify core components while developing functional stories, in which case you need to somehow align architectural decisions taken in several places,
  • or a few teams are responsible for core components consistency, in which case you must ensure that they are responsive enough to current and mid-term requirements, with a sustainable pace (sustainable pace includes quality code and just enough development).

To support the 1st option, you need to have the right people organized the right way. It can be tech leads within teams, with hands on, or super-brains above us common mortals. I never believed super-brains are the optimal solution, but apparently some organizations have the right profiles to make it work. And synchronizing tech leads might be difficult if you have too many teams, too much pressure, too many sites, different priorities between teams and so on. Which is why you end up with the 2nd solutions in some contexts.

So why not trying an open source way of working within your organization? Make your source code public to other teams, support them, make sure your PO takes their requirements into account in your backlog, for instance by organizing votes for features requests. And when you see you’re on the same page with other developers, you can even give them the right to check-in some code directly. This may seem obvious and simple to you, dear agilists. But phrasing it as an open source mindset will instantly ring a bell to the nerds you’ll be explaining this. And frameworks, i.e. governance models, already exist out there (apache, eclipse,…).

What do you think?