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.

You Are Not Your Code

The last thing I would ever suggest would be holding more meaningless meetings … the problem is not meetings, per se, rather the challenge is ensuring they are meaningful.

Once you learn to accept the fact that you are a fallible human being you will not get into a defensive crouch whenever somebody criticizes your work product (whatever it is).  Generally, your life is improved with the growth of any virtue – in this case, humility.  The big win is that your willing cooperation will help you become a better programmer/developer.

It is popularly – and incorrectly – believed that programmers have to be introverts.  An extroverted programmer is somebody who looks at your shoes when talking with you.  But programming, software development or engineering, is a people business .  Somebody who has trouble communicating with customers or other team members – is a liability – no matter how fast they can sling code.  In fact, they may be more of a liability the faster they sling code.

Recently, we were cleaning up some code that had been written by a former team mate and discovered that they had imported a bunch of complexity into a project to solve a fairly simple problem.  Two problems there … first, it indicated a massive failure of our code inspection process which we immediately moved to fix (that won’t happen again) … second,  the programmer was running open loop and had failed to consider what would happen if they weren’t the one maintaining the code.  Clearly, this could have been prevented by doing code reviews/inspections.

Not every organization is ready to implement inspections (a/k/a peer reviews).  A certain amount of preparation is needed.  Here is an inspection readiness framework to see if your team is ready. 

People

  • Champion
  • Management/leadership commitment
    • No commitment = lack of involvement, motivation
    • Do not proceed without upper level management commitment
  • Team member understanding
    • You are not your code – egoless programming
    • Personal commitment to quality above “being right”

Process

  • Policy structures
    • Review the code, not the person
    • Results not used for personnel measurement (may be used to direct remediation)
  • Training
    • Effective meetings (please!)
    • Inspection process

Technology

  • Tools – issue tracking, etc.
  • Measurement/metrics – defect rates/types
  • #1 Challenge / thing to overcome
    • Convincing management that a quality process – especially one that appears to be manpower-intensive – is crucial to the success of the product and, ultimately, the company.  Inspections, in particular, have a proven track record in the industry.
    • A decision of how much effort to spend on inspections comes from evaluating the risk-reward trade-off … time-to-market vs quality.  Note that even early adopters are unlikely to appreciate a product that produces wrong results or crashes often.

To review:

  • Inspections help us improve as programmers/developers
  • Even introverts can benefit from attending review meetings
  • We discovered – too late – that our inspection process failed and it caused rework reducing unneeded complexity introduced to a project by a now-departed programmer

Inspection readiness boils down to people – process – technology … each are important and the approach needs to be balanced

Convincing management to make a commitment to inspections will be the most significant challenge to overcome in getting an inspection process stood up.

The Hero Syndrome

A “super programmer” can be 5x – 10x more productive than the average programmer. That is an astonishing difference and you will know if you ever work with one … it is obvious that they just “get it” better and faster than those around them.  Does that make them a good and valuable member of the team?  Well, maybe.

Patton once said “… a staff officer of uncongenial disposition should be relieved irrespective of any other qualities.”  Presumably including their productivity.  The point he was making was that the staff was a team and the friction caused by an ill-disposed person would be destructive to the team morale and overall team performance.

The seduction of hiring and retaining a hero is that things get done … and done fast.  The question, of course, is what gets done?  Is it the right thing that is getting done – the team’s vision of what is to be produced – or just the hero’s vision.  Tony Stark works alone … OK, with Jeeves the bot … basically alone.  He works on his vision of what is needed.

It is not impossible for a hero to be a good team player.  Take a virtuoso violinist … if the orchestra is playing Beethoven and the violinist is playing Mozart … well, he might be playing Mozart the best it has ever been played … and it will all sound like crap.

Keeping the hero on board with buy-in to the overall project and what is being developed by others can be a particular managerial challenge.  If your favorite hero can only see their own vision – rather than make the team’s vision their own – then you will have a challenge.  The hero may generate so much code so fast that it looks like waste to toss it out … easier to switch the vision.  The waste, though, was on the part of the hero … they wasted their effort on their vision rather than the team’s.  That is not to say that they mightn’t actually be correct and the team might really need to change their vision … 

Attrition.  Well, the hero rides out of town and the townsfolk are left with … themselves.  The more the organization has relied on the hero, the more difficult this is.  The team/organization has to be prepared to lose any team member … at any time … for any or no reason.  Murphy’s laws of software development includes:

  • The more important a resource is to completing development, the more likely it will be missing when needed most.
  • Corollary: If a resource is needed to complete development then it will go missing and do so at the least opportune moment.

The right way to employ a hero may be as a hired gun … a contractor … bring the hero in to solve a specific problem and then let them go.  The problem specification should include that the solution is documented so that the team can sustain it long-term.

The Software Quality V

A software development project is often, if not usually, complicated by many moving parts. Let’s make some sense of all that.

There have been more than a few software development process models proposed over the past 50 years.  From the engineering-/architecture-based, (much-scorned) waterfall model to the present-day “agile” process.  One thing is certain … something else will eventually come down the road … and it will be presented as the final, absolute  best possible solution to the software development process woes beleaguering software projects.  And it won’t be any of those things.  But it will solve some problems (and introduce some new ones).

What can we say is pretty universally true about software development?  Well, we know a few things for sure

  • First, we need to know what we are building before we build it.  Not necessarily the ultimate end – like an architect’s rendition of a proposed building – but we do need to know what we are building next.
  • For what we are about to build … we need to have an idea of how we are going to build it.  And if we have more than 1 person working on it … they had better have the same idea of how the thing is going to be built … or you end up like this:  ___ —-  (railroad tracks that don’t marry)
  • While building it, we need to do the construction with high quality materials (that is, code … the statements that are written need to be written well – both correct and understandable).
  • Finally, when the parts are all put together, everything works together to do what we intended to do in the first place … assuming that hasn’t changed along the way …

Agile and waterfall don’t differ from each other in that requirements precede design, precedes code, precedes integration … they differ more in the fact that waterfall attempts to build the whole building while agile – with the whole building in mind – worries more about building a floor (or a room) at a time.

Where does quality fit into this picture?  At each stage of the process … there are quality tasks/activities that pair up with each of the engineering/development steps.  The usual picture is a V with the two sides of the V representing the activities of development and quality

After the introduction of the computer “terminal” which is already an archaic term – so … after punched cards … software development has always looked like “typing” (now called “keyboarding”). And it looks like anybody can do it. As you know, if you have ever tried to write (well) even a short essay … There is a big difference between writing and typing.  There is an even bigger difference between coding and writing … and typing.