Developing A Development Team – Part II

How does a group develop integrity – wholeness, cohesion, unity?  How does it become a team? Last time I talked about trust and shared values in accountability, performance, and communication.  Let’s keep drilling in.

There needs to be clarity on roles and responsibilities.  There is dynamism here … rigidly defined roles with rigidly specified responsibilities fail in a world where different people bring different strengths (and weaknesses) to the table.

Roles will – or should – generally define what the person with that role is expected to produce during different stages of the SDLC (software development life cycle).  The role imparts the responsibility to the person with the role.  Before a person is assigned (or accepts) a role, the person should know what responsibilities they are shouldering.

Senior engineering responsibilities include mentoring junior engineers … one problem with an ad hoc development team is that there is no sense of permanence … not that anything is really permanent these days … but there is no sense of continuity … no sense that things will continue on after our involvement has ended.

There also needs to be clarity on authority.  Team and project management generally rely on authority rather than persuasion to get things done.  A self-directed team will exercise that authority over its own activities … but that team needs to be above average before it is truly capable of self-direction.

Finally, what should be done about “social loafers” or “toxic team members?”  I want to spend some time on communication so “toxicity” is going to have to have its own blog post …

So … communication

A gelled team communicates.  That is probably a no-brainer, but you may be surprised at how little (or how badly) most people communicate.

Communication has 4 aspects:

  1. Transmission (w/ medium) – generally, in technology, speaking/writing … much more generally, it includes art, music, etc.  But we are engineers, not musicians … on the job, anyway.

2. Reception (w/ medium) – perceptually that is hearing/seeing, with luck (and some training) it is listening and reading with comprehension.

3. Cognition – the often neglected art of thinking before speaking and writing or while (and after) listening and reading.  You know you haven’t finished listening until you have reflected on what you heard … absent that reflection you never finish listening to what you heard.

4. Attention – focuses the mind.  You see (or hear) what you focus on … not vice versa

If your attention is focused on thinking about what you are going to say rather than receiving what is being said to you then you are hearing but you are not listening.

People are immersed – drowning – in an ocean of “communication” these days.

We get a tsunami of content – both audio and visual – from our environment.  But it is mostly noise with some few signals sprinkled in.

Signal to noise ratio measures the relative strength of the meaningful (signals) compared to the meaningless (noise).  The internet has a horrible signal-to-noise ratio. 

So … the real question becomes … what is your personal signal-to-noise ratio? 

Mindful communication encourages us to ask whether what we are about to share is “true, necessary, and kind” … we should add “does it improve on the silence?” If we could get some silence, that is.

Developing A Development Team – Part I

There is a reason that all-star teams “draw hard vacuum.” A team is not a collection of individuals.  If it devolves into that then you can stand back and watch it disintegrate … notice that word … dis – integrate … to lose cohesion or unity.  The loss of integrity. How does a group develop integrity – wholeness, cohesion, unity?  How does it become a team? 

Credit where due … I have drawn some of this from the website “thebalancecareers.com” where you can find some interesting blogs on business management and leadership;

To be a team a group needs to have (or develop)

Trust – mutual trust of the team members … if it isn’t mutual then it is a problem.  Different people have different levels of trustworthiness and … what I call “trustwillingness” – a person’s baseline predisposition to trust others.

There must be at least enough mutual trust so that people aren’t walking around with their backs to the wall all day.

An interesting article from June, 2009 by Roderick Kramer in the Harvard Business Review on their website – “Rethinking Trust” … he argues for “tempered trust”

“Salting your world with lots of small trusting acts sends a signal to others who are themselves interested in building good relationships … [, and decades of research by social psychologist Svenn Lindskold and others have proved that it leads to more positive interactions.] It works because it’s incremental (and thus manages the risks intelligently) and contingent (that is, tied to reciprocity). By taking turns with gradually increasing risks, you build a strong and tempered trust with the other person.”

When you think about it … tight-knit teams are all built that way … the individuals learn to rely on each other increasingly over time.  Over. Time.  This doesn’t happen overnight.

Besides the fact that it is just a group of individuals, this is one reason why all-star teams suck … there is no time to build a resilient level of trust.

Beside trust, the team has to have shared values … everybody needs to buy in, more or less, to common expectations of

Accountability; commitment discipline – we can advertise that our team has “extreme accountability” (it is in our corporate value statement), but if the team members don’t buy-in … it is just a despair.com poster waiting to happen.

Shared accountability for team success (failure) – the whole team wins/loses together.

Performance and communication – Clear expectations about the level of performance and how and how often the team will communicate. 

There also needs to be agreement – a consensus – on things like

How the team will make difficult decisions – difficult, as in, somebody is not going to get his way.  That somebody needs to already have signed up to accept the decision if/when it goes against him.  You know you have a gelled team when the wrong decision is made and the person who had the right idea (and has been proved right) feels badly.

How the team will deal with differences of opinion – civilized people (and some developers) know how to agree to disagree without it becoming personal.  Flintlocks at 20 paces is probably not a good way to moderate differences of opinion.  In an engineering environment, the proof is in the pudding (which means, I think, that there is whiskey in the cake).  It’s engineering, not personal.

How the team members will support each other.  Nobody left behind, right?  Read up on the Navy SEALs to get a sense of what it takes to form an elite team. 

With respect to training and team formation, the SEALs have an 80% washout rate … you cannot afford that, but if you are trying to build a top-notch team then you have to have the wherewithal to absorb a certain amount of tech churn as you let under-performers. 

Chances are good that you do not have that kind of wherewithal … in which case you are building a team from average performers that you generally won’t want to lose … unless they are way below average.

A Look At Development Teams

What does a productive, gelled development team look like?  What does any productive, gelled team look like? You may as well give up the idea of working on a high-performing team.  Unless you are willing to do what it takes to elevate your team’s performance.  And that might not be enough.

Even if you are willing to do what it takes, does everybody on the team?

A development team is not that different from any other kind of team.

Let’s face it, if a team is going to have a chance at becoming a high-performing team, it needs to have an overall commitment to excellence. 

On a sufficiently dysfunctional team, one person trying to lead by example or one voice exhorting the team to work smarter, harder, faster, better will be met with derision. 

If it is a manager calling for improvement it will be met with passive resistance (at best).

People have compared development teams to orchestras … or, better, jazz bands.  And some developers do like to think of themselves as … artistes …

but what is different about a development team, though, is that it is supposed to be building a working solution – it is more engineering than art – and that creates an environment that is more like an academic department than an orchestra …. or jazz band … or athletic team …

… and academic departments are never dysfunctional …

Depending on the type of project, the actual development team may be created ad hoc or pulled together from existing staff.  Or some combination of both of those.  Unless you are unusually fortunate, we assume the following:

Your team will be, on average, … average.  That means that – assuming we have a normally distributed population – 68% of the population will be within +/- 1 standard deviation of the mean.  The average.  It also means that 84% of the population will be +1 standard deviation or worse.

I am willing to be convinced that our population of developers is skewed … towards excellence, of course.  But the argument holds that you will not draw your entire team from the lofty reaches of engineering excellence.

The job is to take a generally average group of performers and build them into an above-average team.  It takes an above average leader to do that.

Many of the arguments for self-directed teams presuppose that the team is above average.  An average or below average team will fail at self-direction.

There are more than a few average (and below) performers out there who believe that they are well above average … or that they are owed self-direction. 

If you have the time, patience is a virtue.  The team should be allowed to start work as it sees fit – within bounds.  The team’s metrics will save you.  One of four results can be expected:

Metrics are not produced.  If the team cannot even reliably collect data and produce process metrics then it is clearly below average and incapable of self-direction.

Metrics show below average performance.  Is there a trend showing improvement?  If so then encourage the team and sustain their ascent.  If not then intervention is needed.

Metrics show average performance.  Is that good enough?  Again, is the team showing improvement?  Keep an eye on things and if performance slips, intervene.

Metrics show above average performance … pop a cork and celebrate … everybody wins.

Next time we will talk about building a development team.  What kind of group characteristics and dynamics need to be developed.

Why Is Testing Not Quality Assurance

Dr. Edsger Dijkstra – one of the luminaries in the firmament of computer science – once said: “Program testing can be used to show the presence of bugs, but never to show their absence!”

The proper role of testing in the software development life cycle is to validate the soundness of the engineering process that produced the software.

Testing – as a component of the quality process – follows its own development process often, and properly, in parallel and coordinated with the development of the system.  That is how the “V” described in an earlier post functions irrespective of the actual defined development process in use.

Tests are planned and designed to provide coverage of the system – not only the externally visible interaction with the user, but also coverage of the structure of the code itself.  But that is not all there is.

What the system is supposed to do … usually called the system requirements … is established by the customer (internal or external).  This begins life as a more or less vague idea in the mind of the customer.  Any appreciably interesting system behavior is going to take more than one person to create.  Which means that things need to be written down.  Activities need to be coordinated.

For example, there is no way to “test” a statement of requirements … the only way to assure the quality (correctness and completeness) of the requirements is to review them with the customer.  So, the statement of requirements needs to be written to be communicated to the customer and then reviewed with them.

From the 30,000 ft level, none of the early effort in a project will be “testable.”  The tests themselves are not, strictly speaking, tested, either. 

  • How do you know that the test you are planning to run tests that part of the system that you were planning to test? 
  • How do you know that your test is not actually testing a completely different part of the system than the part you think you are testing?
  • What constitutes a correct set of pre-conditions (what must be true before running the test so that the test has validity) before executing a test?  How do you validate those?

None of this is meant to disparage software testing – it is a necessary activity in any development process.  The point is that testing is not all there is in a software quality process.

I can hear your unasked question: how much does all that cost?  How could it be afforded?  We will take up those questions in a later post.

How much refactoring is too much refactoring?

Here’s a question that came across the transom … it had to do with “… a 2-week Sprint where we went through a massive code refactoring in one of the major modules “ one of the quality engineers was wondering if the development team was being ineffective/inefficient …

The Question from reddit user

  • We are working in a 2-week Sprint where we went through a massive code refactoring in one of the major modules (a web module); the developers’ (5 of them) justifications were:
    1. At the time of the development, they didn’t know how to develop it
    2. To make the codes better for future development
  • After testing was completed, and suffice to say, was grueling as the tester had to go through multiple Sprints tickets and test cases just to re-test all the refactored codes, one of the developers took a ticket from the backlog where it also enhanced another “sub-part” of the module; therefore the tester now needed to re-test 30-50% from the same module again, and the test had to be done within the same Sprint.
    Unsurprising, the tester asked, “if this is the case why wasn’t that “improvement” done on the prior work since the work itself is very close to the already completed work? The developer said it will not be as difficult as the prior one, which seemed to be an attempt to appease the tester, but the tester was not having any of it and complained to the test manager that the development process is being ineffective and inefficient in their development work, wasting testing time.
  • To the experienced QAs, what do you think of this situation? Is the development team being ineffective and inefficient? Was the tester right in concluding as such? What went wrong?

My response:

  • The question posed (constant code refactoring) and the scenario presented looked like two different things. So, first step is to validate that we were dealing with a chronic – rather than an acute – problem.
  • If the “massive code refactoring” was needed – and both rationales presented appear to be adequate reason for re-factoring – then there should be little argument about doing it. That doesn’t make the refactoring “constant” unless it recurs sprint-after-sprint-after-sprint …
  • If there is constant refactoring then there is a serious project management/engineering breakdown. The quality problem in such a case is far removed from testing because the is a systemic process problem leads to a lack of stability in the product.
  • In the case where there is a single “massive re-factoring” (not constant) then … having left major issues lying around in the backlog and/or allowing major issues to be picked up late in the sprint … that is a different project/engineering management issue. It suggests that the estimates of the effort required may have been be seriously flawed.

What does it take – what does it cost – to write one line of code?  What do you include in the “what does it take” – documentation (user and developer), what quality assurance activities are needed, what tools or environments are needed, etc.

In our consulting practice, we have seen projects running with no estimates whatsoever.  And no process for improving estimates, if there were any.  How do you know how many user stories can be developed or issues resolved in a sprint if you have no idea of what it will take? 

Estimation of the complexity of software work is notoriously difficult.  New, green field development, often has so many unknowns that it seems impossible to estimate.  My very first comp sci instructor’s rule of thumb seems to work:

  • Take your first impression (guess) of the time it will take.
  • Multiply it by 2 (or 102)
  • Increase the units by 1 order of magnitude
  • So … an original estimate of 4 hours becomes … 8 days

It is appropriate for a manager (or customer) to ask: what will it take (cost, effort) to get something done?  How long – wall clock time – will it take?  If you cannot answer those questions then it doesn’t matter how “agile” your process might be … you should not proceed.

Listening Through the Noise

Signal to Noise Still Life

The shouting match that is the current incarnation of the internet leads us to the unavoidable question: why listen better when the signal to noise ratio is so bad? I am using “listen” figuratively here … online we “listen” to others by reading … but the principle holds.

I might want to back up and explain what a signal-to-noise-ratio is …

Well, it compares the level of a desired signal to the level of background noise. Too much noise drowns out the signal. Kinda like trying to listen to an AM radio station (remember those?) during an electrical storm. Or trying to have a conversation in one of those God-forsaken conference centers that infest all of our major cities.

Most often, signal-to-noise ratio (SNR or S/N in the technical literature) is used to describe the quality of radio broadcast – or narrowcast – transmissions. It is also used to describe how clean the sound is in audio equipment. Or the picture in video.

The amount of useful content available online is amazing. Unfortunately, it is often buried under a mountain of relatively useless, repetitious SEO-enhanced drivel. Search engines try to cut through the fog of noise for us, but there are no guarantees that what ends up on the first page of a search is anything like what would be most useful.

Spending time/energy to learn to “listen” better seems a waste when the quality of the content is low – or drowned out by nonsense.

Actually, it is precisely now that better listening is needed.

Arguably, the internet would be markedly improved if people spent more time “listening” and less time “talking.” A groundswell in that direction would automatically reduce the amount of noise in the environment.

Be the signal, not the noise.

More anon …