You Have the Wrong Team

As a project manager, you have just staffed your project. Sorry to be the bearer of bad tidings, but you have the wrong team. If you an experienced project manager, you already know this. But you did the best you could from the resources you had available. It is the wrong team because:

• You are missing the experience you need in some key areas, and
• The team members don't necessarily work well together.

Agile practices help here, particularly the practices of collocation (and you do sit with your team, don't you?) and pair programming. If you are missing experience, collocation and pair programming lets you grow that experience by judicious pairing. Knowledge transfer is quite rapid and efficient in this environment. Collocation also dampens down the "finger pointing" that often plagues teams. ("He doesn't understand!", "She is so stubborn!", and the like.) It is much more difficult to talk behind someone's back when she is sitting in the room with you.

If team members still have difficulty working together, your being in the room provides insights to the solution. Is it a matter of tone (challenging, dismissive, personal rather than business)? Then coach on interaction style. Is it disagreement on technical matters? Ensure swift resolution before it becomes personal.In this area, Agile practices can be a disadvantage:collocation and pair programming will exacerbate negative relationships. Whereas you might be able to ignore or defer action when each team member sits in their own cubes, such deferrals are quite destructive in an Agile team with its close proximity.

Net-Negative Producing Programmers (NNPP)

Agile luminaries have coined the term NNPP to identify team members whose overall impact to the project is negative. That is, the work they do is less than the harm they do to their colleagues' productivity. An NNPP may be productive outside of an Agile environment. In a cube, their griping has no listeners. There challenging, terse tone goes unheard. But given their visibility in a collocated environment...

I recently saw on the Web a report purporting to show the impact of one bad apple on the rest of the team. A single individual typically can negatively impact other team members numbering in double digits! So indeed, one bad apple can spoil the whole bunch.

There are several ways to identify such individuals:

• Observe. Being in the room, you can see the behavior. Even more important, you can see the impact on overall team. The situation can be corrected by coaching, or ultimately, removal.
• Ask the team. The team knows who is acting incorrectly. Borrow a lesson from Survivor, and let the team vote someone off the island.
• Who gets picked last? If pairing is practiced, who is the person no one wants to pair with?

If you fail as a project manager to act quickly on identified NNPP, morale issues will quickly ensue. Your inaction, in particular, will be glaringly obvious to the team. Your leadership, dedication, and even competence will come under question.

Once more for emphasis: Failure to address an NNPP problem will rapidly destroy team productivity.

The Continuing Issue

The real fatal flaw in staffing projects, and Agile projects in particular, is not realizing that the project staffing needs change throughout the project. Projects that acquire their staff, and then stick with that staff throughout, will incur excessive costs if not fail outright. Staffing must be adjusted throughout the project.

A few years back on an eight-month Agile project, I made 10 staff changes in the first 6 weeks. The core development team had 16 different participants, but only 4 were on the project for the entire time. Rather than being a disaster for such team instability, the project set high water marks for productivity and quality that have yet to be touched.

Why does staffing need to be adjusted throughout a project? It is for several reasons beyond staff quitting and needing to be replaced:

• The needs of the project change throughout the project. DB tuning will be important at some stage, but not others. Knowledge of systems with which the project much integrate will be needed at some time. The general load of analysis, development, and testing will drift during the project.
• Team members will grow during the project, particularly on projects lasting more than six months. Exploiting this growth is part of good team management. Again from the above example, I reduced the number of developers to six toward the end of the project. They produced so much code, however, it took 17 testers to keep up. The developers skills had increased that much.
• An inbred team will cease innovating. Studies of innovation reveal a significant drop in innovation in a team that has been together for as little as six months. New blood is needed, even if only to challenge the patterns of current thinking.

As a project manager, you must constantly be alert to tweaking the team. You may raise eyebrows by constantly shifting your team composition; ignore them. When the need for an expert has passed, roll her off the project. Bring in a specialist when the need arises; exploit collocation and pair programming to harvest the knowledge and release the specialist. Perhaps that resource you really needed was not available at the start of the project. Bring them on board when they are available.

Successful team tuning requires building a strong relationship with two groups. First, be willing to share your experts with your colleagues. Hopefully, they will reward your good will with the loan of a needed expert of their own. Don't hoard resources when the need has passed; rather, release them to reduce your costs and maintain the morale of the resources. Second, build great relationships with your staffing or resource management team. Send them flowers or buy them a case of beer (or both); they will start to call you when a resource becomes available that you might use.

Application development is chaos; react or face corresponding chaos in your team.

Building a Better Programmer, Part 2

To increase the productivity gains promised by the Master-Journeyman-Apprentice (MJA) model, programmers must progress up in the model. In Part 1 of Building a Better Programmer, we detailed the techniques by which programmers can gain the skills resulting in improved productivity. In this post, I will discuss paths to programmers enrichment, likely timeframes for the process, and failure rates. I will again draw from the MJA model for learning OO skills, a key enabler for Agile application developement.

Apprentice to Journeyman

If you can move your Apprentices to Journeymen, you can effectively double your productivity for those complex, business critical systems you maintain and enhance. There are certain enablers that are required for this transition:

• Willing Apprentices (supported in their efforts by management)
• Journeymen or Masters from which to learn

I have used a couple of paths to assist the transition of programmers from Apprentices to Journeymen, both in ThoughtWorks and in the industry with good results in both cases. For OO programming, the goal is the same in both cases: Teach the Apprentice to think like an object programmer. That means teaching the Apprentices to break problems down in a different way, to recognize when programmers are structured poorly per OO principles, and build up a repertoire of techniques by which to do this.

Path 1 involves a combination of training and mentoring. Training assists in quickly providing the new vocabulary for the Apprentice, and mentoring provides the continued support for applying the new techniques to the daily problems the programmer addresses. Without mentoring, the value of the training is significantly diminished. Without mentoring, the pressures of delivery will drive the Apprentice to apply the old, familiar techniques to solve the problem. Old habits are reinforced; new techniques are forgotten. And worse, the new techniques become labeled "theoretical" or "academic" or "irrelevant to real problems." Net result: education wasted.

Path 2 forgoes the training, and simply provides the mentoring. The training is gained by working closely with Journeymen and Masters. Pair programming is important in this environment; collocation is absolutely essential. Path 2 takes longer; the Apprentice must pick up the vocabulary in the course of the work. Path 2 is probably more expensive; the productivity gains come later, and the time of Journeymen and Masters is taxed in doing bits of training here and there as the need arises.

There is a Path 3: Pick it up from reading the books. Self-taught Journeymen are rare, but I have met them. They also took a frighteningly long time to make the transition, with a lot of discarded bad code in the wake. I cannot recommend this approach for even the brightest of programmers.

If you can adopt Path 1 (training and mentoring), you should expect most of your programmers (60% or more) to make the transition from Apprentice to Journeyman in about six months. Some will be there quicker; some will take a bit more time. Expect failures; in my experience, about 20% cannot make the transition at all. The individuals who will not make the transition can be identified pretty quickly (a month or less); they can be placed back in the roles they had before and continue to be productive for the organization. The usual cause of the failure to transition is that they lack the conceptual skills to be effective OO programmers. I have seen a few other cases of failures in senior people. In these cases, the senior person realizes that the junior people understand this better than they do, and choose to disengage rather than reveal the lack of a gap. I take these failures personally; I feel I didn't create an environment where they could learn safely.

I developed specific training for this transition over a decade ago. The first class affectionally called it OO Bootcamp. I brought the course with me to ThoughtWorks several years ago, and it still carries that moniker today. I will post more on OO Bootcamp in the near future.

Journeyman to Master

The transition from Journeyman to Master is much more difficult. You should not expect more than 20% of your staff to ever make the transition. Most of your good candidates have deviated from strict application development, and are probably serving as your system and application architects, effectively ceasing their learning as programmers.

But with the whopping productivity boost and the ability to leverage Masters to make more Masters, it is well worth investing in their growth.

Masters must be excellent programmers. Their vocabulary is deep and wide. By and large, they have extensive experience applying their knowledge to real world problems. Similarly, their conceptual skills are excellent. This allows them to manipulate objects in their heads, forming solutions to difficult problems. Finally, domain knowledge is helpful, but not quite essential.

If you describe a business problem to a Master programmer, she will see objects dancing in her head, forming patterns that solve the problem. This comes from developing an inherent sense of object relationships, a suite of problem-to-object-solution maps, and confidence born of solving similar problems before.

Hence, the transition from Journeyman to Master can take a while. In general, expect a couple of years. I have seen a few instances of faster transitions (only six months or so); in all cases, the individuals were extremely bright, conceptual thinkers, and had many years of programming experience under their belts. (They were also colleagues from ThoughtWorks India!)

Managing Programmer Improvement

In the prior post, I listed the techniques to enable programmer skill growth. In order of importance, they are pair programming, collocation, communities, and training. Project managers and senior managers should facilitate these practices as much of this as possible.

There is one other charter I would give a project manager when a focus on skills is important: Bring back better programmers. In other words, measure the project manager on both delivery and skills growth. If the project manager delivers the project but doesn't grow the people, then, well, at the least a permanent productivity boost to the organization has been lost; at worse, gross negligence has occurred, and I don't want to use that project manager again.

Building a Better Programmer, Part 1

Programmer productivity varies much more widely than project management spreadsheets would suggest. Differences within a moderately sized team can be 5:1, 10:1, or higher, discounting any incompetent programmers. In a previous post, I discussed how to assess the skills of the individuals. In yet another post, I extolled the more expensive talent was actually a huge bargain with their productivity boost.

But knowing the skills, are you stuck with this team? Is your only option as a project manager to swap team members out to improve your mix of skills? The answer is a resounding no. You can improve your mix of skills.

One of the attractions of the Master-Journeyman-Apprentice (MPA) model for me is that it clearly indicates the path to improving the skill mix:

• Apprentices need constant supervision as they begin to acquire skills and apply them for the first time. Gross, project-impacting mistakes await unsupervised Apprentices trying to apply their new knowledge for the first time. (Would you let a first year med student perform open heart surgery on you?) The natural supervisors? Journeymen (and not project managers!)
• Journeymen should choose the Masters from whom they will learn. It was the case with craftsmen of the Middle Ages, and is just as true today. They need exposure to such people to improve their skills to the next level. Self-taught Masters are quite rare; more often, Master programmers I know learned at the hands of another Master programmer.

Another alternative model for Master/Journeyman relationship come from academia: The relationship between PhD's and their doctorial candidates at universities. The doctorial candidate selects a professor under which to study. In exchange for guiding the doctorial candidate, the professor gains additional research capacity in his field of study. When the professor feels the student is ready, he presents him to a committee of other PhD's for examination. This committee decides whether the candidate is qualified to join their ranks. So a self-controlled Academy of Master Programmers is another interesting model.

It behooves the project manager to create an environment to supporting this learning. The rewards for supporting this learning are large productivity boosts without a corresponding growth in costs (yes, you should pay your Journeymen and Masters more, but they will be happy with less than 100% or 500% raises).

Enabling elements (in order of importance):

• Pair programming. Not only is pair programming as productive as two individuals working alone, it creates an amazing learning opportunity by pairing Apprentices with Journeymen, and Journeymen with Masters.
• Collocation. Conversations cannot occur unless people are speaking distance from each other. Throw in a convenient whiteboard, and knowledge transfer will take place.
• Project teams. Project teams that are deliberately formed to expose key individuals (Journeymen) to a Master programmer will create communication between them; knowledge will grow.
• Communities. Whether formal or informal, encourage and support communities around the skills (OOP, database, dynamic languages, .NET, etc.). Communities are quite a bit less effective than the above alternatives, primarily because they involve participants choosing to participate on their own time. This caters to a subset of candidates only.
• Training. Training is largely ineffective for all but Apprentices. But for Apprentices, it inbues them with new terminology and techniques. Hands-on training is much preferred to lectures. All training is ineffective if the techniques learned cannot be immediately applied to current project work. There is near zero retention for material that is first used a year after it is taught. Consider this when staff can sign up for education, but will have little opportunity to use the material in their normal job.

A subsequent post will talk about specific paths of transition from Apprentice to Journeyman, and from Journeyman to Master.

Masters, Journeymen, and Apprentices: Part 3

In the previous blogs on this topic, I claimed that there is a huge productivity difference among Masters, Journeymen, and Apprentices when working on significant, business critical systems:

Role	Productivity
Apprentice	1x
Journeyman	2x
Master	5-10x

This is observed productivity from many Agile projects.

So, what do you do with this information?

1. Assess the skills of your developers
2. Adjust project staffing, absorbing all the Masters and Journeymen you can find (the rate difference does not equate to the productivity difference)
3. Work to boost the skills of your developers

Let's start with the first point: Assessing the skills of your developers. For this example, these guidelines here apply to OO skills in particular, but you can easily morph these into other skills.

• Apprentices are those programmers that are not yet Journeymen. You do expect Apprentices to be competent in a programming language and associated tools (IDE, unit test tools, debuggers). They can write code without fumbling and resorting to syntax guides. They can use the right tool at the right time. They may be learning what bad OO code looks like, but lack the tools to figure out how to get rid of it.
• Journeymen have developed a broad OO vocabulary. They understand OO principles, and apply these principles in their code. They have a rich set of design patterns they exploit, and a broader set they understand. They can quote solutions to code smells drawing from their refactoring vocabulary. They are clever users of their tools, exploiting the nuances missed by Apprentices. Journeymen stuggle, however, when trying to design an object solution to a business problem. They are not yet comfortable with exploiting their OO design skills to address these problems.
• Masters are Journeymen with the extra ability to decompose a business problem into its parts. They also discern refactoring paths for ugly code, particularly where a series of patterns must be applied. The source of their productivity lies in their ability to find a great solution (simple and elegant) quickly, whereas Journeymen may have a few false starts.

So how do you assess where each of your developers fit? The easiest way is to have a Master programmer work with each programmer for a while (as little as 30 minutes). That will be enough for a Master to discern the current level of a programmer. You might also get a feel for the potential of a programmer in that short time, but that is a bit more dangerous.

You don't have a spare Master programmer around to do the assessment? For Apprentices and Journeymen, there is a good alternative. Since the difference is largely knowledge based, testing is a valid approach. Test their vocabulary; show them bad code, and ask how they would fix it. Personally, if a programmer can describe the Composite design pattern to me with three or four places where it would be appropriate, I am pretty sure he is at least a Journeyman.

How about Masters themselves? That is a bit tougher, but I would propose the following: Master programmers know Master programmers when they meet them. They talk a different language; they discuss problems in higher, abstract terms. They can relate experiences using almost any design or refactoring pattern. Verify that the legendary programmer in your organization is a Master programmer by getting references from luminaries in the field. Once you have found one, let her figure out who the others are. Chances are she knows a couple, and those couple know the rest.

Warning: Don't be surprised if you have no Master programmers. Don't be surprised if some of your architects think they are, but are really not.

More in the next post about growing Journeymen and Masters.

Masters, Journeymen, and Apprentices: Part 2

I previously suggested that classifying programmers as Masters, Journeymen, and Apprentices provided a better way to understand and manage the productivity differences among programmers. The analogy to craftsmen of the Middle Ages is deliberate:

• It reinforces the image that programming is a learned craft, not some special science. I am definitely in the camp of thinking with The Pragmatic Programmers.
• Skills like OOP proficiency seem to be learned best from others; books faire poorly in teaching these skills. This aligns with the craft model well.
• It defines some tiers of productivity, but not too many to make planning difficult.
• The level of independence (or rather, the need for supervision) is modelled well. Apprentices need constant watching; journeymen do not.
• Journeymen in the Middle Ages would find masters under which to study. There was an implicit agreement to learn and teach that was largely voluntary on both parties. I like the self-selected learning concept.
• It is a skill classification, not a job title. This aligns better with Agile and Agile teams.

My colleagues have suggested a few nice refinements or alternative systems.

One idea I like is breaking the Apprentices into two classifications: Those who are learning the skill, and those who are not (because of ignorance or just not choosing to invest in that particular skill). This segregation aligns with the different treatment of the two groups. Learners are encouraged, nurtured, and provided with opportunities to learn. The non-participants are educated in the advantages of the skill to solicit their participation.

Another colleague, Dan North of ThoughtWorks, uses a three-tier system based on his school of Japanese martial arts: Shu, ha, re, with re corresponding to apprentices. In his school, the lowest tier, re, focus on the mechanics of the moves: blocks, counterpunches, avoidance. Once the body learns the moves, the mind moves toward applying them in situations. This is the domain of the ha level of competence. Practioners achieving the shu level are innovating; in an unexpected situation, these practioners may conceive of new techniques on the fly because of their fundamental understanding of the principles.

The appealing aspect of Dan's model is that ha are expected to teach re, and shu are expected to teach ha. Indeed, you cannot achieve the shu level unless you show you are also competent to convey the knowledge to others. Dan's model reflects my belief that some programming skills (like OOP proficiency) are most easily conveyed in person, not by books.

Masters, Journeymen, and Apprentices: Part 1

I have proposed the heresy that all programmers are not created equal. I further dissed most typical correllations to programmer productivity (title, salary, etc.) may not be useful in predicting differences in productivity. Thus I have turned to a different system.

I classify developers as Masters, Journeymen, or Apprentices. This is a taxonomy I picked up from Ken Auer of RoleModel Software; I think he got if from a former company he worked at, KSC. But I have seen other references in the literature to it as well. The model refers to craftsmen of the Middle Ages, but applies to many disciplines today that involve learning a skill.

Briefly, an apprentice is a developer who is still learning the requisite skills. Constant supervision is necessary because an apprentice may not know when she/he is doing something wrong. Techniques are being learned, but the why of the technique is still a bit vague. Stringing together techniques is a bit beyond the apprentice.

A journeyman has mastered the techniques of the craft. Supervision is rarely required. Given a task, journeymen can complete it in reasonable time with quality results. But they are not yet masters.

A master has all the journeyman skills, but also is able to innovate within the craft. Given a new problem, the master can conceive of a solution. Then the journeymen can be turned loose to help him implement it.

In an Agile team, the skill I am looking for is object-oriented programming (OOP) because Agile hinges upon the ability to write code that can change. Most programmers don't know how to do that, particularly with object-oriented programming. Don't confuse object-oriented programming with object-oriented languages like Java, C#, C++, or Ruby. Using one of those languages (sadly) does not ensure an understanding of object-oriented programming.

An apprentice in OOP is a effective programmer and can construct loops, methods, and classes, but is still learning how to separate the business problem into objects. Encapsulation is being learned (which means no getters or setters for the classes). Code is being placed into the appropriate classes rather in giant god class. if statements litter the code as the apprentice is still learning design patterns to eliminate them. Class sizes and method sizes tend to be larger than smaller. Code requires comments to aid in understanding, and blank lines are common in the middle of methods to group code together. An apprentice is beginning to understand the patterns of bad code (the imfamous code smells), but lacks the tools to understand how to eliminate them.

The journeyman is adept in OOP techniques. The classes exhibit crisp conceptualizations distinguishing them from each other. Boundaries are clear; methods are small. Design patterns are common, and exist in inverse proportion to the number of if statements. else statements are quite infrequent, and case statements have vanished. (I write about one case statement every 18 months or so.) Given a problem and a broad outline of a design, journeymen will implement it with little need for supervision or support.

A master has all the above skills, plus a near magical ability to hear a problem and see objects for a solution. They never seem stuck, and always seem to have a solution to the code smell that is stumping the journeyman. A quick conversation with a master can remove a barrier slowing down a journeyman, or reset the direction being taken to save significant effort.

So why bother with this classification? The corresponding productivity model, particularly on significant, business critical applications. Let's say a regular programmer produces at 1x. An apprentice is essentially a 1x programmer. Then a journeyman is a 2x programmer. There is that much difference in learning those OO techniques. But a master... Well a master is a 5x-10x programmer! They can literally run circles around an apprentice. Even more important, when an apprentice can't get anything done because of the complexity of the problem, the master cuts through it like a hot knife through butter.

A true example from a former client project: In the third release of a project, we reduced the team size to six programmers. These six programmers were keeping 17 acceptance testers hopping just to keep up! The client was running around the halls trying to find additional testers. The six programmers: four masters and two journeymen, a virtual team of around 40 in productivity. No wonder it took so many testers to keep up.

So in my resource planning spreadsheets, I literally identify apprentices, journeymen, and masters as separate resources, and use 1x, 2x, and 5x multipliers to get a virtual body count. I use the virtual body count to compare to non-OO waterfall estimates of the same work. And I never count a swap of a master for a journeyman.

More musings on the M-J-A model in later posts...

The Secret Assumption of Agile

I assert that there is a secret assumption behind successful Agile. "Secret" may be a bit too strong, but it is certainly under-articulated if not completely unarticulated.

Agile succeeds when you write code that is easy to change.

I grew up with phased (waterfall) processes. I was taught that a needed design change discovered during the coding phase would cost you ten times the cost of knowing about the need during design. A design problem found in test would cost 100 times the cost of avoiding the problem during the design phase. Based on this cost model (which seemed correct in my experience following it for 20 years), code reviews, design reviews, detailed diagrams, rigorous architecture specifications were all cost saving techniques no sane project would ever do without.

Agile touts that it can easily accommodate change at a reasonable cost. That is, if you knew about the requirement in some detail before the project started, the cost to implement the requirement would be 1x. If you find out about this requirement in the middle of an Agile project, the cost to implement will be about 1x as well (maybe 1.1x, for example) and not the 10x or 100x a waterfall process would predict for a change that would affect the design and adjacent code.

What is going on here? Are all our experiences in waterfall development simply calculation mistakes? Were we using the wrong languages? Were we simply stupid?

"No!" to all of this (although I have had my moments of brilliant stupidity). What has happened is that we have discovered ways to write programs that minimizes the excessive cost of change. I count several technologies that facilitate change, including:

• Normalized relational databases
• Rules engines
• Object-oriented programming
• SOA (decomposition of an application into loosely coupled entities)

All of these techniques share two aspects in common:

1. They simplify the problem to allow other sound techniques to be applied, and
2. They eliminate duplication so that when change is needed, it can be applied to one and only one place with confidence.

My favorite among these techniques is object-oriented programming. By this, I do not mean using an OO language, although that is very helpful. I speak about a style of programming that exploits the fundamental OO concepts.

An example may help here. At a client a few years ago, we were asked to rewrite an existing system. The existing system was a Web-based application, Java platform, with Oracle database backend. The new system was a Web-based application, Java platform, with Oracle database backend. No difference. The reason for the rewrite: The system could no longer be changed in a timely fashion, and business was being lost. The rewritten system has exceeded expectations, met all business needs, and is easy to maintain and enhance (which has been done.) The original system had 79 Java classes. When we finished with the new system, it had 1400 Java classes. We found 1400 different, unique things to model. When a new requirement was being considered, it may impact 20 classes. But the remaining 1380 classes were untouched and ran their unit tests perfectly. Writing code in this particular OO style is different.

Are the Agile pundits (and I am one of them) deliberately hiding this "secret" assumption of Agile? I don't think so. But all the luminaries in Agile that I know have been programming in this style for many years (and most for decades). It is inate to their thinking. When I was exposed to this style of programming 15 years ago, it took a while for me to understand. But after that point, even my Excel macros in VBA are structured very differently.

There will be more discussion of how to learn this style in future posts.

Collocate to Communicate: Part 1

Collocation presents challenges. Kent Beck advocates starting an Agile project by bringing in a wrench (spanner for my UK colleagues) and screwdriver on the first day and fix the furniture. In my experience, fixing the furniture is important, but the furniture police are lurking, and in a large company can outnumber the Agile team. Nevertheless, I have nearly always gotten the team collocated on an Agile project.

The furniture police (I actually have never met one) are not the only inhibitors. Most of the challenge is from recalcitrant team members not wanting to leave the comfort of their little spot in the office. "Oh, where am I going to put my pictures?" "What if the school calls?" (I'll address the abject terror of pair programming later.) Tom Allen of MIT's Sloan School cites a key success factor for getting the team to work in the room in his book Managing the Flow of Technology: Get the manager to move in with the team! So I tend to focus on the manager, and the rest of the team becomes a bit less reluctant.

So why bother? Is it really worth all the effort? Yes!

I recently saw a statistic that indicated that a collocated team gets a 15% productivity boost by doing nothing other than sitting together. That certainly echoes my experiences, and is not surprising. Consider what Tom Allen says: There are three reasons people talk to each other.

1. They have common interests,
2. They work for the same manager, and
3. The chance that you and I talk varies inversely by the square of distances between our chairs. (Tom Allen got tenure for this one; he was formerly an aerospace engineer for Boeing.)

In layman's terms, the last point means that if I double the distance between our chairs, there communication will be reduced by a factor of four. If I double the distance again, the chance of communicating drops by a factor of sixteen. Tom also measured the "intellectual distance" created by a staircase or elevator: 100 yards. Now square that. If the team you work with is on the next floor with a staircase or elevator separating you, you might as well put the team on the other side of the globe. The distance impact is huge.

So taking Tom's rules in mind, how do you manage this situation? The first factor, common interests, you have no control over as a manager no matter how many lunches or recognition events you schedule. Mark that one off.

With the other two, you can play around. A bad solution: Sitting a department that works for the same manager together. Yes, the department will communicate, but they will also point fingers at all the other "idiots" in groups they need to work with, whether it be customers, sponsors, or colleagues that carry a different job title. Yet overwhelmingly, that is what I see.

With Agile teams, I want to rip the team members from their department caves and place them together. They will still talk to their colleagues back in the cave -- that's Tom's second rule. But now they are sitting beside those previously labeled "idiots", and are discovering that they are not so stupid after all.

There are even more benefits I will get into later. But for now:

Collocation is key to successful communication, and communication is critical to Agile success. So I encourage you to persuade, plea, or even bully your management into creating collocation space.

All Programmers are NOT Created Equal

All programmers are not created equal. There. I have said it. It is our equivalent to saying, "The emperor has no clothes."

There is much evidence that, indeed, all programmers are created equal. My exhibit for this: hundreds of thousands of spreadsheets built by project managers. Okay, maybe I will count that as hundreds of thousands of exhibits. I have even contributed at least several hundred of them myself. It doesn't make it true, no matter much it makes the spreadsheet easier to use.

Okay, so it may not be true that all programmers are equal. But it is it approximately right? In my experience (many, many years) on real projects with real delivery deadlines, there is an order of magnitude difference between programmers (that is, 10x difference). Even after throwing out the incompetent programmers (who produce zero), the really good programmers are ten times better than the really mediocre programmers. So even in approximate terms, all programmers are not equal.

Ask a programmer you know about this. (You may be a programmer yourself.) Do they know a really good programmer? How good is she/he? You will likely hear of legendary feats, impossible tasks done in a weekend, feats of heroism worthy of superhero status.

So as a project manager, you should seek these resources out. The "one" on your spreadsheet can become a virtual "ten". That is contingency, risk management, and a cheap insurance policy, all rolled up into "one".

How do you find these programmers for you project? Sorry, more bad news here for the project manager: These resources don't automatically correlate to most of your company metrics.

• Some correlation with experience: Look for years programming; discount years of being an architect or any other non-programming role that doesn't involve personally writing code.
• Negative correlation with years since directly writing code for the job.
• Slight correlation with title/level: Does your organization have tiers of programmers (Dev 1, Dev 2, ...)? Higher levels are more likely to be stronger programmers. If your company has a true meritocracy (versus pure seniority system), a top-tier programmer must have been good at some point to be promoted. So there is a bit better chance that it is still true. Caveat: Negative correlation with years since directly writing code for the job.
• Negative correlation with non-programmer titles: Speciality titles are signs that (1) the skill is now gone, or (2) "Those that can't program, [fill in your favorite job title]". Be wary of architects, particularly if they come with adjectives (web-services architect). Designer titles are a little less risky, but have the same flaws. Ask the key question, "Do you write code?" Run away from any answer like, "I am past that" or "I leverage others".
• Some correlation with salary: The better programmers are probably paid more. Someone has recognized that they are worth holding onto. Most organizations are not as dumb as we think about matters of survival.

So, if all these indicators are not so good, how do I as a project manager know I am getting at least my fair share of these super-programmers? Easy. Ask the programmers. You may not recognize their legendary feats, but they know about them. You may need to prod them a bit; you may need to tolerate some geek-speak. Nod knowingly, and listen for the names. Another way to prod: Ask them, "If you were marooned on a island with the natives that are cannibals, and you had to program your way off the island, who whould you want to be there to help you?"

How many of these super programmers do you need? As many as you can get. What happens if you don't have them? Well, that is a topic for another day.

[This is part of the People thread of this blog. See The 3 P's of Agile: Process, People, and Pods for the overview.]

The 3 P's of Agile: Process, People, and Pods

This is the first post on the topic of Process, People, and Pods. This series of blogs will explore Agile programming beyond the traditional boundaries of "an alternative to waterfall".

So where does this name come from?

Process refers to the Agile alternative to a phased process (aka waterfall). But the process discussion will go beyond that. Agile has its roots in the Just-In-Time (JIT) manufacturing process; Lean is the more popular name for these techniques as this thinking explodes past the manufacturing sector. So Process will also address management techniques that promote Agile versus traditional engineering techniques like Gantt charts that cripple Agile productivity.

People addresses the different way to think about the most important component of software development: The people that conceive it, create it, and make it available for use. Let me summarize how radical the Agile thinking should be here. If you don't believe that waterfall is the right methodology, what do you think about people that are titled after phases of waterfall? In People discussions, we will expose the flaw in thinking of about people as architects, analysts, designers, developers, and testers. Not only is Agile productivity rooted in breaking this thinking, there are positive moral benefits to be gained.

Pods takes the people point to the next level. If the job titles are wrong, what about how we organize departments around these titles? Pod refers to an ideally structured Agile team. If the name invokes B-grade sci-fi flicks, you have caught a bit of the roots of the name. It also comes from thinking of the synergy of a bean pod full of seeds. In Pod discussions, we will discuss ideal Agile organizations. What about the career tracks we define? I would suggest that Agile teams are organized differently. Agile teams should act differently, be trained differently, and be appraised differently.

I look forward to feedback on all of this!