This link has been in my blog backlog for a couple of months, waiting to work its way into a blog post. But I’m fed up waiting so here it is raw.

What Is Software Design? by Jack W. Reeves on Developer Dot Star

Originally published in 1992, before Java, before C#, before Agile, when Lean was just breaking out of Toyota and before the web (almost) this is a classic piece about software design.

Reeves argues that all coding is design. His specifics might refer to C++ but this could be any language.

Just in case you are in any doubt: I completely agree.

I was helping a team set up their board (white board, Kanban board, Scrum board, call it what you will) for Agile working the other day and it dawned on me I use a whole bunch of heuristics I’ve never seen written down. So here goes:

• I like magnetic white boards best myself but I’ve seen teams use walls, cupboards and flip charts too. The important points are: big, visible things you can stick other-things on it.
• I prefer to use index cards but many teams use Post-It type stickies. If you use index cards you need a means of sticking them to the board which is where the magnets come in.
• You can divide the columns: classically this is To do, In Progress and Done. Of course Kanban teams use many more columns.
• At first I used the same dry market pens to mark the columns as to make notes on the board. The trouble is these lines tend to disappear. This is a particular problem with Kanban teams who have more columns and so more movements to make. So now I use coloured electrical insulation tape to mark the columns. This is much easier to see and lasts a lot longer.
• Leave space on the board to include Team or Project name and the end date of the iteration. You might also find space to keep a burn-down/up or cumulative flow diagram.
• You don’t need a very big board: I normally use 120cm x 90cm, again Kanban teams tend to need bigger boards because they have more columns.
• You can buy a suitable board from most stationary suppliers for less than £100. If your company can’t afford this (or won’t pay) you have problems which Agile isn’t going to fix.
• Remember to buy magnets, dry wipe pens and something to remove the permanent market someone is going to put on there eventually.
• Coloured magnets are fun but so far I’ve not found using the colour of a magnet to convey information hasn’t been worth the extra effort
• Boards are usually mounted on the wall or a stand but, I prefer them to be free standing because you can carry them around. If you have a meeting in another room you just pick the board up and carry it there. And its a team exercise to move it.
• We had an accident with a board once: it was hit from behind at the start of the planning meeting and everything came off. But that turned out to be good, we looked at everything in more detail. Sometimes I now remove everything at the start or during the course of the planning meeting and only replace it if I need to.
• Don’t put designed on your board: there isn’t enough space. By all means have another board for designs.

One of the important, but often overlooked, roles in any software development is the “needs” guy. I put it that way to be as general as possible. Its the role which decided what the customer/end-user actually needs (sometimes wants but doesn’t need).

I’ve blogged before (many times, The Product Owner role (August 2009), Requirements: The next challenge for Agile (February 2009), Books for Product Managers (December 2008) among others) about the Product Manager role. However, Product Managers, or to give them their full title, Technical Product Managers, only really exist in genuine software product companies (including software as a service models). In corporate IT departments and software service companies (i.e. ones that write bespoke software for a specific customer) the role doesn’t exist.

In these companies the “needs” role is usually (or should) be filled by a Business Analyst. I blogged about these when I blogged about System Analysts earlier this year.

Both Product Managers and Business Analysts (BA) are concerned with the “what” of the software product, but how they decide this is different. Basically:

• Product Managers find the need by looking outside the company, at a market of multiple potential customers
• Business Analysts look inside the company at a single customer, with potentially many stakeholders involved

I’ll probably blog about this more in future.

However, he BA role is much misunderstood. As a title I think it ranks second only the “Project Manager” in abuse. In some places BAs are really System Analysts, in others they are Project Managers, in others they just gather the requirements. The definition I like best is “Internal Consultant.”

Thats one of the reasons I really like the Business Analysis Maturity Model.

You can view this model as model for individual career development, but I prefer to view it as a model for corporate advancement. At the “low end” BA just rather up everything “users” think they want, at the high-end the BA is responsible for discovering what the business needs to improve.

When you do this the BA role looks a lot more like a Product Manager role: its about deciding what will advance the company and product in both cases.

And its important from an Agile perspective. When the Product Owner/BA role is played as a “requirements gatherer” then there is little scope for the BA to add value and, more importantly, there is little flexibility in what is delivered. The BA becomes just the guy who communicates the need to the people who write the code.

When the BA role is played as an consultant, working with customers/users and the development team to fill a business need then the conversation changes. Rather than discussing which, and in what order, features will be developed from a given shopping list then conversation can centre on how best to satisfy a business need and maximise value.

In short, the BA Maturity Model is a critical, and until now missing, piece in understanding the BA role in Agile teams and Agile development.

Programmer, software engineer, software developer, coder, developer, code-monkey, build engineer, tester, software tester, test automator, test engineer, quality assurance engineer, analyst, business analyst, system analyst, product owner, product manager, requirements manager, subject matter expert, domain expert, project manager, change manager, programme manager, development manager, iteration manager, release manager, deployment manager, scrum master, team leader, technical lead, development lead, architect (system architect, solution architect, software architect), consultant, coach, designer, user interface designer, user experience designer, product designer.

Did I miss any? – There are a lot of roles in software development teams and even more titles. Does your team have a full set? Do you need them all? How do you choose which ones you have, and which you don’t?

And everyone of them offers a solution to your problem. So….

In walks the Programmer (Software engineer, software developer, etc. etc.) and says: “Yes, I understand your problem, what you need is some software writing. Only us programmers can do that so don’t worry about that testing lark, or analysis. Just introduce me to some customers and I’ll work it out.”

The Business Analyst walks in next: “Its all very well writing something, and its all very well making sure it works. But, is it the right thing? How do you know its what you need? Us Business Analysts are trained to understand what you need and give those requirements to the programmers and testers.”

Next in is the Tester. “You see, the problem is that Programmers don’t really know what you want, and when they do they make mistakes. So I’ll test everything and ensure it works, and that it is what you want.”

Very convincing. Next you talk to a Project Manager: “yes, these programmer and testers are very good but have you noticed how long they take? Unless there is someone here to organise them, and dare I say push them, then you’ll never get anything.”

You see, everyone (every role) offers to solve your problem. Maybe by creating a solution, maybe by ensuring its the right solution or maybe by making sure that it all fits together.

And these roles overlap. Programmers can talk to you about what you need, so can Testers. Project Managers like to have a chat too and Business Analysts claim its their right.

As you get more people things get more complicated. They seem to make work for themselves. So you need an overall Development Manager to manage you teams. You hire Architects to ensure the Programmers really do it right.

More people begat more people: Release Managers, Programme Managers and Team Leaders appear to organise people. Designers, Build Engineers, and Consultants appear to specialise in parts of the system.

They all claim to have the answer to your problems but things look worse.

Then someone tells you about Agile. You need a Product Owner, a Scrum Master and a Team. More roles, and the people you already have don’t want to give up their titles so you add some more.

And the holders of all these roles claim they have the solution to your problem.

They can’t all be right.

Thing is: there is only one role you absolutely must have on a software development project. That is the guy who does the coding: Programmer, Software Engineer, Software Developers, call them what you will. If you are not getting code written you aren’t doing software development.

Which of the other roles you have depends on the complexity and nature of the work, the size of the team, the approach you take and your wider organisation.

This doesn’t stop the specialise from telling you they have the solution to your problem. Which makes it all confusing.

I intend to keep with this theme of roles for a few blog entries, so watch this space.

A while ago I tried to answer the question “How many software teams are using Agile?”. My best efforts put the answer at somewhere between 5% and 15%.

In the search for some other data I’ve recently been look through Capers Jones “Applied Software Measurement” (2008). It is packed full of interesting statistics and I really must buy a copy and read it in more detail. Anyway, Jones gives his hypothesis of project in this table:

Type of development	Number	%
End-user	2,500	2%
Agile	20,000	13%
Web	12,500	8%
Systems	8,750	6%
MIS	70,000	45%
Commercial	3,250	2%
Outsource – US	17,500	11%
Outsource – offshore	15,000	10%
Military	7,750	5%
Total	157,250	100%

(In case that table gets mangled, the first column is the type of development, the second the total Jones looked at and the third the percentage of the total.)

Jones puts the number of Agile projects at 13%, firmly inside the range I give. Of course there are two caveats here. Firstly, the ways Jones has sliced and diced the numbers leaves me wondering how he has counted military work running Agile, and outsourced work running Agile.

Second, how do we know if a piece of work is Agile or not? All the evidence I have tells me that an awful lot of teams are saying they are “Agile” and frankly aren’t. As Kevlin Henney suggested on re-twittered (from somewhere or other) recently a better question to ask is “How are you Agile?”

I’ll get Jones book and read it some more. One other thing he mentioned stood out: getting metric on software projects is hard. He says its like searching through debris, lots of rubbish then occasionally a nugget. Which sums up how I feel about software metrics now. Its quite like I imagine archaeology.

I recently stumbled across Les Hatton’s site. I’ve owned one of Les’ books for probably over decade (Safer C, a classic) but this was the first time I’ve looked at his website. I highly recommend a perusal of the site and reading some of his papers. Apart from anything else he’s an even more interesting guy than I thought he was (and I already though he was interesting!).

One set of his papers looks at the power-law nature of software code. I’ll admit I couldn’t follow all of the academic speak and advanced maths terms – which might disqualify me from reading some papers but it
more a sign that I didn’t take the time to work it out in depth. (Most of his papers are written in a very accessible style.) The key point I took away was that he extends James Noble’s work to non-OO systems. Hopefully I’ll find time to go back and read more of these papers in depth and make sense of the bits I skimmed this time.

Another paper which stood out was “How to build successful complex systems: lessons from open source” with his suggestions for how to build the NHS IT system. Until I read this I was unaware that the Welsh
Health Service had taken a different route to the English one, had spent far less money and had actually produced a successful system.

Les, like many others, sings the praises of the Open Source movement. He’s right, there are some very successful Open Source products out there, but, as I’ve pointed out before, most Open Source
projects fail. And when I say MOST I mean tens of thousands fail for every success.

Fortunately Les’ suggestions allows for this; he suggests a Darwinian process with seeds 100+ development efforts and over a series of rounds reduces them to one winner.

Although Les suggests this in an Open Source context what he is actually suggestion is also a Venture Capital model. He proposes to give over 100 teams a little bit of money (seed money in effect) to create an initial system. Year on year winners are selected to continue development, these are given a bit more money. That sounds exactly like Angel funding, VC Round A, VC Round B, etc. etc. funding. OK, Les model is “open” because the winning teams get to pick over the remains of the loosing but even that exists in commercial activity: failing companies get bought by the winners who keep the best bits.

Either way the result is the same: rather than one “too big to fail” NHS IT project we have a number of small projects which compete and can fail. If we remove the ability to fail from the process then we have to
pay for failure.

Whether it be evolution, capitalism, IT projects or even banks, if failures are not removed from the system then change is inhibited because the winners cannot really win.

This is the important thing about failure. Forget that myth about learning from failures, the important thing is that it eliminates something that doesn’t work.

As regular readers may recall (one of my favourite expressions!)… I regularly ponder my subscription to the MIT Sloan Management Review. After a few dull issues – which leave me wondering if it is worth the money – it has once again come up with an issue with a couple of articles which justify the price for the whole year.

One of these is “Why Forecasts fail. What to do instead.”

The insights I find illuminating here are:

• Sophisticated, complex, models are good at fitting past data (“forecasting wit hindsight”) but they only not very accurate in predicting what will happen in the future (they tend to extrapolate)
• Simple models are not so good at explaining past data but are better at forecasting the future
• Human judgement is worse than statistical models at predicting the future
• Experts don’t predict any better than the average person
• Averaging the predictions of several independent individuals is more accurate

The article cites research to back up these assertions.

This fits in well with what I tell teams when I’m coaching and training in Agile methods. The simple estimation and velocity measures I advocate are better than the complex models which are too often preferred.

And it is no use asking a system expert (architect, senior developer, what-ever) how long it will take, their estimate is no better than anyone else. But, getting several different estimates (e.g. using planning poker or similar) is.

One technique suggested by the article is something I’ve tried in “future-spectives.” You say to the team, or individual, “Imagine we are at the end of the project, we have finished on time, in budget, everyone is very happy, what did we do right?” and the opposite: “Another failed project, what did we do wrong?” Imagining yourself in that situation can produce useful insights.

One of the ideas I talked about in my Jax London presentation is something I call the Scrum hegemony and it deserves a few notes.

In the early days of Agile there was a tendency to equate Agile with XP, that changed a few years ago and Agile become (almost) synonymous with Scrum. I’m not saying Agile was XP or Agile is Scrum, just that to the uninitiated it can seem that way. (I blogged about this nearly 2 years ago now, see “Scrum is the new XP”.)

In many ways the Scrum people did a fantastic job of making Agile acceptable to the corporation. They had data and Harvard Business Review articles to cite, they didn’t ask the corporation to get into technical details (like TDD) and they had a friendly (English) name which avoided the word EXTREME! And most of all they had Certifications. O, don’t forget a pretty good marketing machine.

All this had the effect of making Agile acceptable to suited corporate types who didn’t know the first thing about software development but knew projects were always late. Ironically Scrum isn’t much more than XP, indeed, it is less than XP.

Consider XP: you can basically divide it in two. The bits about engineering (continuos integration, test driven development, refactoring, etc.) and the bits about managing the work (iterations, stand-ups, stories, etc.). Scrum, as documented concerns itself with the management side.

Granted Scrum expands on roles, Scrum adds some concepts like self-organising teams, adds some terms like backlogs and renames others (iterations to sprints) and adds burn-down charts but the management side of XP is basically Scrum, and Scrum is XP.

Purists might like to argue about which stole from which but the point remains: they are the same.

Scrum is devoid of the engineering practices, but as I’ve noted before in this blog: Scrum without the engineering practices is heading for trouble.

XP’s success, and the even bigger success of Scrum had the unfortunate side effect killing off most of the other Agile methods: FDD, ASD, Crystal, etc. Pockets still exists (especially with DSDM) but that is all they are, pockets. That was good for understanding but bad for experimentation and learning.

That’s now changing. The Scrum hegemony is now ending. Kanban, and perhaps other methods, are now offering alternatives. David Anderson’s Kanban insurrection is again offering an alternative. Kanban is again allowing the experimentation and variation in process that the Scrum hegemony has been stifling.

Don’t get me wrong, I don’t think for one moment Scrum is going to roll over and disappear, or that Kanban will dominate. Scrum will continue to be the Agile method of choice for corporations, it will be the 800 pound gorilla to use a phrase. But it will no longer be the only show in town.

Kanban is on the rise and drawing more attention to Lean, Software Craftmanship is on the rise and Tom Gilb’s work is being re-examined. There has long been a divide in Scrum between those who believe in “one and only one Scrum” and those who see “Scrum A, B and C” (I was going to post a link here to Jeff Sutherland’s blog but it appears he’s removed the post). Now there is a schism in Scrum: there are two bodies awarding Scrum certification, Scrum Alliance who’ve been around for a while and a Scrum.org backed by Microsoft and Ken Schwaber.

One of the good things about Scrum was that it was clear about what it was and was not – unlike Agile. This increasingly looks in doubt. As Scrum has grown more popular variations have set in, differences in certification and types of Scrum only add to those differences. The danger for Scrum is that it goes the way of the word Agile and becomes all things to all men.

That risk is echoed in the wider Agile family now. I welcome the rise of Kanban, not just because I think its a good system but because I think it is offering opportunities to think again about how we do things. But the end of the Scrum hegemony could leave the Agile as a whole fractured and incoherent, and decidedly not the type of thing corporations should be involved with.

Worst of all, it could see a new methodology war. There would be no winners here, only looses. Scrum and Kanban, and all the other methods, shouldn’t be rivals just alternatives. Unfortunately between the method zealots and in the commercial market I fear that message will be lost.

Time to bring this mini series to an end. I’ve talked about

• Segmenting Architects
• Architects who aren’t
• Architecture or Design?

As a quick rule of thumb consider:

• The Product Owner (Produce Manager/BA): is concerned with the What
• The Project Manager: is concerned with the When
• The (your type of) Architect: is concerned with the How

And some closing advice:

• When you have a software system to design or fix, look to an architecture team not an individual. The team can share the vision in creating and exploitation.
• Never, ever, give someone the title Architect: give them the role yes, but never the title. Once you give them the title it is difficult to remove. And since you don’t know how their ego will respond you risk creating an problem. Architect is a role, not a title. Give people architect responsibilities but make sure they are still defined as a Software Engineer or whatever term you use were you work.
• The moment an “Architect” asks for an expensive tool to draw UML in then its time to let them go. UML can have a role but it isn’t worth spending money on. Expensive tools allow people to hide, architects shouldn’t hide. A cheap tool might be acceptable but don’t let them hide behind it.