Developers must know the business domain – I

Knowledge of the business domain is essential to developers.  They must know the business as well as the business folks know it.

We have all worked in environments where the business analyst’s word is gospel.  The analyst specifies a solution, and the developer translates it verbatim into code.

This approach to software development is less then optimal.

Blind football

Imagine sending a running back onto the field blindfolded.  We tell him, never mind that you cannot see a thing.  The analyst will relay  instructions to your ear.  Follow them to the letter and Bob’s your uncle.

  • Run 6 yards on a 37 degree angle to the left.  Your left, not mine.
  • Now tack right, 82 degrees, and run 15 yards at a speed of 26 miles per hour.
  • Wait, 300 pound linebacker at 7 ‘o’ clock.  Wheel, dummy, wheel.
  • Uh oh, too late.  No, wait.  The linebacker got tripped by his own cornerback!

See, the defense has blindfolds on too.  In fact, all 22 players on the field are blind as bats.  They are unseeing puppets, lumbering about, whose strings the business analyst is pulling.  Don’t you think there will be stumbles?  You bet there will be.  The business analysts have to be superhuman to get everything right all the time.  Your team must loose the blindfolds.

Pre-empt the bug

Business folks and analysts are as fallible as the next person.  There will be holes in the information they provide.  These gaps can cause  errors.  Developers must recognize and fill those gaps so that they can avoid those errors.  The alternative is to let the error happen, hope that someone catches it, then fix the error.   How can this ever be better than avoiding the error in the first place?  

Agile, by First Principles

Agile gives me the warm and fuzzy, because like all good systems it can be characterized by a small set of rules, first principles, from which we can derive all other relevant lessons.

first principles

Arguably, the Agile Manifesto, is the most famous attempt to lay out the first principles of the agile approach to software development.  The Agile Manifesto comes in two forms – an elegant and concise one, which is shown below, and a slightly longer, more expository one that I will leave you to discover.

Shorter Agile Manifesto

The problem with first principles

First principles are distillations of wisdom that practitioners gained only after a lot of experience.   For that very reason, they often make little sense to the newbie engineer.  We read the words and some of us ask, “Really?  Why ?”.  We don’t have an answer.  I know that is how it was for me.   Eventually, I acquired the critical mass of hard knocks that were necessary to see the inevitability of those first principles.

These days I seem to practice Agile almost instinctively.   So much so, that I struggle to explain what I am doing, and why I am doing it.   In trying to unpack how I go about software development,  I tried to write down the working set of principles that I work by.

Once the words were on paper, I could see how they derive from the Agile Manifesto.  It reminded of a line from Gandhi, “I’ve traveled so far. And all I’ve done is come back… home.”

A very personal agile manifesto

Below, you will find my working principles for agility.  Notice that my words don’t exactly match those of the Agile Manifesto.  That is as it should be.  My own personal manifesto, so to speak, is necessarily colored by my particular work experiences, and my personal strengths, weaknesses and prejudices.

Again, let me emphasize, this is not meant to be consumed blindly.  Ask yourself why this is valid. Think about what implications these ideas have.  Don’t be surprised if you do not understand or even agree with some of these.   This works for me; this, among other things, makes me an effective IT worker.

  • The only acceptable ‘status’ is working software that delivers business value.
    • Don’t tell me the status. Prove it.
      • Where is the code? Let me read the code. Let me see it running.
      • Where is the test? Is the test correct? Is it adequate? Let me see the test working.
  • The earlier you know the status the better.
    • Short iterations.
    • Frequent feedback.
    • Continuous integration.
  • If you can’t answer the question, “what is done, and what remains”, in terms that the business understands, you’ve got nothing.
    • User stories, in strictly business terms.
  • Change is the only constant.
    • You will never get correct nor complete business requirements at any one instant.  The same applies to solution specifications.  Roll with it.
    • No design nor solution will ever be right the first time.  Roll with it.
    • Priorities will change.  Roll with it.
  • Information is indispensable.   Documentation, and meetings are incidental.
    • Putting words on paper, and communicating are two different things.
    • Just because you talk, talk, and talk, does not mean you are communicating anything useful.
  • If you are not putting software in production, for business to do business with, you’ve got nothing.
    • All the process in the world, all the fancy tools, the “best and brightest” people, mean nothing, if you are not delivering.
    • The answer to every question of the kind, “is this the correct process, is this Scrum, is this Agile”, is one simple thing.
      • If it helps you deliver, yes.  If you are not delivering, none of it matters.
  • No battle plan survives contact with the enemy“.
    • Human beings are unreliable.  Human judgment is unreliable.
      • Estimates are less correct, the farther out into the future they extend.
      • You will never anticipate everything that can go wrong.
      • Every process will break down.
      • Remember, Eisenhower’s advice, “In preparing for battle, I have always found that plans are useless, but planning is indispensable”.
    • You must be able to adjust and keep moving forward.   How?
      • There are no short-cuts.
      • This comes entirely from the attitude, ownership, knowledge, and skill, that people on the ground can bring to bear.

Is it a Bug or an Improvement – Irrelevant to agility

I see development teams struggling with the question – is this a bug, or an improvement.  A team that is agile (exhibits agility) would not care.

All the same to me

Tickets come my way.   Some are labelled bugs, and others, improvements.   To me, whose only mandate is to get the damn work done (aka agility), they all look the same.  What I do in response to either a bug or an improvement, is exactly the same.

All of the work requires analysis.   Gather all of the information that is available (documentation from client and analysts, production data, existing code, other tickets,  tests), and separate the essential business requirement from the solution that supports the requirement.  Then make sure that all stakeholders (clients, analysts, managers, developers, testers) have the same view of the matter, problem and solution.  Often, what they ask for is not what they need, and it is sometimes necessary to improve the solutions they specify. This requires constant and nimble communication.   Next construct the solution, which includes testing what we have constructed.  Finally, deliver the solution.

Every ticket is this same dance.

Why care, exactly

I can only think of two reasons for fixating on the difference between a bug and improvement.

First, the green-eyeshade brigade use the difference to figure out who to charge for the work.  A bug forces the development team to swallow the cost.  An improvement can be thrown into the client’s bill.

Second, it might help us figure out who to blame, or to use a more charitable perspective, it might point out where there is room for improvement.  A bug implies the developer messed up.  In cases where the bug is discovered in production, the finger sometimes points to the tester.   An improvement implies the business analyst, or perhaps the client missed something the first time around.

Of the above two reasons, I have sympathy only for the former, the billing problem.  This is mostly because I am low on the totem pole, and know very little about money matters.   Allow me to punt on this.

The latter reason leaves me cold, as you will see below,

What am I gonna believe – statistics or my lying eyes

Numbers can lie.

It is hard to have faith in statistics that classify work as bugs and improvements, when everyday I see my comrades-in-arms struggle to distinguish between the two.  More often than not, we shove tickets into one bucket or the other so work can move on. Typically, some power-that-be is breathing down our necks, or the task management tool is forcing us to make a selection.  Come time to review the work, we all know that the pretty pie charts, which the managers pass around, are nonsense.

I don’t need statistics to know the folks that I work with.  

I work with business folks, development managers, analysts, developers, testers, tech-writers, and so on.   After I spend a couple of weeks in the trenches with them, I know what their strengths and weaknesses are (don’t look now, that’s agility).

Take a developer for instance.   I read a developer’s code.  That tells me how she thinks through a problem.  I know if she can tell a story in simple, straightforward terms.   Can she find the shortest, most direct path between points A and B?

Consider a business analyst.   I read the documentation he creates.  That tells me if he simply knows the business or if he indeed is good at observation and analysis.  Does he see only the surface of things, or can he lift the hood, and identify the patterns and sub-structure that the surface covers?  I will know if his communication skills are adequate.   Can he accurately, clearly, describe what the business is, and what they are asking for?  The more I know the business (agility) the easier this gets.

I use the applications that they specify and build.  I know if they have empathy.  Do they know their users?  Can they walk in the user’s shoes?

I watch how they negotiate one on one conversations, and meetings.   This tells me if they know how to listen.

You get the idea.  Every little thing that a person does is a breadcrumb I can follow, especially if I know how to do that work myself (agility).

My recommendation – chuck it

If at all, only the bean counters need to worry about whether a piece of work is a bug or an improvement. Hide this question from the people that actually do the work. This question is irrelevant to the conduct of the work.   If you hear someone in your development team kvetching about bugs and improvements, make them buy lunch for the whole team (agility).

Focus on Agility, not Agile

For some time now, folks have been emphasizing that we have lost sight of agility, while frantically pursuing Agile.   There is little value in dogmatically following one Agile methodology or the other, Scrum for instance, while loosing sight of underlying purpose of such methods(in a word, agility).

So much Agile, so little Agile

To put it another way, Scrum, in and of itself, is not important.  Rather, why Scrum makes the recommendations that it does, is the important thing.

Take just one small example.

Scrum recommends we have a daily standup meeting.   I have been in teams that hold these meetings religiously.   However, it soon becomes clear to everyone attending the meeting that we are just going through the motions.   The meeting is just another way to waste 15, to 30 minutes of time every day.  In these environments I learned precious little in standup meetings.  Well, I did learn how many different ways there are to talk a lot without saying anything.

When I really want help from a team member I find a way to talk to that person on my own, one on one.   If someone else wants something from me, they come and find me, either electronically, or physically.

If I want to learn the status of the work, in my capacity as a tech or team lead, I pull down the code, build and run it.   I test the code myself, and I learn things that nobody tells me in standup meetings.

Information is essential.  The meeting is not.

If I was working with peers whose skills I had confidence in, and whose word I could take implicitly, the standup meeting may give me the information I am seeking.   However, more often than not, what I hear in a standup meeting falls well short of a full wallet.   Fine. I am not an engineer for nothing.  I don’t need that standup meeting to know exactly where each of my team members are.  I have other ways of skinning this cat.  This is not Scrum.  However, it surely is agility.