Heathrow part 2 – a major learning failure

Uncategorized / /

 

I’m really disappointed, for years I’ve been pointing to Terminal 5 construction as a great example of lean ideas at work. It gets delivered on schedule and then what? Mess. Seems everyone will forget it was on time and remember the opening week nightmares.

How come after being an exemplar of Lean techniques during construction Terminal 5 was such a mess at opening?

To recap: BAA decided that T5 was such a big project, and so strategically important, that they couldn’t follow “traditional” construction practice and outsource it to the cheapest bidder. (A quick look at the Wembly Stadium debacle is enlightening.) So, BAA more or less re-invented construction project management along lean principle and delivered their new terminal on time and on budget.

Then BAA handed over T5 to British Airways who messed it up. Weeks of passenger delays, cancelled flights, lost baggage and humiliating publicity which some have called a “National disgrace”.

Most of the problems seem to have been on the BA end but BAA is not in the clear. BAA treated T5 construction as a project, the project (mostly) ended when T5 was given to BA. At that point the bad management, sloppy thinking, and lack of customer respect endemic in the rest of BAA came to T5.

The BAA side of things is an example of how the Project Approach is wrong. BAA should have taken a Product Approach. The product needs to be fully in use, product development continues.

Lesson for software companies: It is a Product, Not a Project.

Now to BA.

From the reports I have read BA has confrontational management. Managers were scared to report problems up the chain so senior managers never heard of problems.

Lesson for software companies: Managers need to stay in contact with what happens on the ground. How actual employee are doing their jobs. Macho management is bad management.

Moving into T5 stretched BA’s resources. Staff from T1 had to move to T5 and find their way around a new terminal with new machines. They had only had limited time to familiarise themselves with the terminal and equipment. In fact, during the learning process they needed more time than usual.

Lesson for software companies: Allow time for learning, don’t skimp; over-staff your departments when big changes are happening. The time of change is not the time to extract savings. That comes later.

Not only is BA confrontational but it has poor employee relations. I suspect the flow of ideas between employees and managers is poor. Employees probably aren’t willing to trust managers and give extra performance. Why should they be?

Lesson for software companies: Trust your employees, help them trust you.

Rightly BA didn’t attempt to move all their flights in one go. However, they did move an awful lot in one wave, and at the same time moved other flights from Gatwick to Heathrow. This wasn’t an incremental delivery.

Lesson for software companies: Incremental delivery means many small deliveries. Not two big ones.

It seems we have a major learning failure at T5. BAA construction teams learned completely new ways of working to deliver on time. But this learning failed to cross the boundary to BAA operations and BA. How often have we heard that before?

 

Heathrow part 2 – a major learning failure Read More »

T5 disappointment – Heathrow part 1

Agile / / / 2 Comments

A slightly off topic look at another industries problems…

Why should I blog about airports? – this blog is about the business of software development. Well I could argue that its all business and within remit but I’m still its stretching it a little.

The reason to blog about terminal 5 (T5) is because past I have held it up as an outstanding example of lean practices in action.

• Compare and contrast: Terminal 5 and Wembley Stadium
• Terminal 5 is Lean

T5 is part of Heathrow airport, and Heathrow is owned an operated by BAA. In the past I’ve talked about T5 in isolation but, as all good system thinkers know, we have to look outside the immediate to understand the whole.

I think there are some interesting lessons to be learned from the recent mess at T5 and at Heathrow in general over the last few years. Some of these lessons might just help software developers.

Lets start with the re-occurring horrors that are Heathrow airport – well talk about the T5 opening mess another day. Take some examples:

• Disruption and Flight backlogs
• Reoccurring delays
• Baggage handling problems and cancellations
• Knock on problems elsewhere
• General unhappiness with the airport – I agree, I live close enough to it to make it pointless trying to use another and the experience is ghastly.

The paradox at Heathrow is that while T5 has been an exemplar case-study in Lean Thinking the rest of Heathrow shows many of the faults of traditional thinking non-lean thinking.

Travelling through Heathrow is an exercise in queuing: Lean Thinking tells us how to manage queues. Heathrow is an operating at the absolute limit of capacity, therefore it is highly efficient but prone to disruption. The slightest problem and everything is messed up.

While BAA managers have claimed that the opening of T5 would solve the problems they ignored changes on the existing terminals that would make real improvements for passengers. They have looked for a single big fixed (T5) over a myriad of smaller fixes.

For example:
• Why not strip out some shops and provide more seating? Why not strip out some shops and make popular ones bigger? OK I know why, because they make more money, we’ll come to that.
• Why not copy Liverpool airport and give people the option to pay for fast-track security? People who have a genuine choice will be more accepting.
• Why not give free water bottles for people who have their water taken off them at security?
• Why make it worse for passengers with petty, pointless rules? – the one that caught me last year was taking a cup of coffee (bought airside) with me to the departure gate. This is not allowed. Why not?

(By the way: has anyone noticed the one place at Heathrow where you can’t by a Grande Cappuccino? – The baggage hall, waiting for a case which may, or may not, appear is devoid of shops. Yet it’s the place where I’m usually most gasping for a drink, chocolate or newspaper to read while I wait.)

Part of the reason BAA has gone for the one big fix is because the myriad of small fixes requires staff co-operation, and it turns out Heathrow is a bastion of confrontational management, highly unionised workforce and prescribed working practises.

Customers have very little choice: BAA control the three biggest airports in the London area. Once you are at the airport BAA control everything you can do – doubly once you get through security.

So what are the lessons for software developers?
• Lean/Agile has its limited: No matter how lean T5 construction was the rest of the airport is a disaster. One group doing lean will not automatically infect everyone else.
• Pay attention to your customers: if you treat them badly they will start to find ways to buy competitor products, or simply stop buying (travelling). Vendor lock-in will eventually be broken.
• Queues work, they make you more efficient but they reduced your ability to react and change. Nobody likes queues, they make us all miserable. The fact that many software queues are hidden is no better.
• Management need to co-operate with those who do the work. They need to accept that a million small solutions can be as worthy as one big one.
• Short term gain (all those shop rents) detracts from long term improvement and customer experience. Sometimes the bottom line has to take second place.

Fundamentally the economics of Heathrow (and BAA and BA) are just wrong. I might go into that some other time, for the moment I’ll refer you to the Economist. Their analysis and solution is spot on. The objectives of BAA, shop holders, Government security, airlines and passengers are at odds. Nobody seems to benefit.

Perhaps the biggest problem is the business models of BAA and British Airways (which dominated Heathrow and is dominated by the airport) are utterly dependent on squeezing as many people through the airport as possible. This is not good for our national economy – let along London – but because BAA and BA carry so much political clout they are able to keep the Heathrow economic-fantasy protected. Making Heathrow responsive to real economics (as we did with coal mines, ship yards, steel factories and car companies) would actually solve the problems.

So the last lesson: It’s the Economics, stupid.

Software companies, unlike Heathrow, live in the real economic world. In the short run a company may be able to run a business model which harms its customers but customers have choice. So you’ve got to get the economic incentives aligned. If you are developing software make sure your economics benefit everyone: what is good your customer should be good for you.

T5 disappointment – Heathrow part 1 Read More »

More comments on ACCU conference

Agile / /

Some more comments, observations and thoughts about, and provoked by, the ACCU conference. No particular linking theme.

Jobs and banks

There were a lot of bankers at the conference this year – or rather developers who work in banks. In truth this is always the case but this year I think there were more. It also gave the opportunity to find out what was happening in the financial job market.

Before Christmas I think many people were expecting a shake-out similar to that of 2001/2002 but it seems the effect of the crisis or credit crunch is very mixed. I observed a few weeks ago that one effect has been to push up rates and while some banks do seem to be shedding staff others are still hiring and demand is strong. I talked to someone from one (American) bank which had drastically cut back staff, while people at another (English) bank were still hiring lots, and another (Scottish) bank which recently bought another (Dutch) bank is having to hire lots of people to help integrate the systems of the two banks.

Lies, Damned Lies and Statistics

I’ve had a downer on metrics and statistics for a long time. But I’ve also been aware that getting the right data and measuring the right numbers is often the key to success. Tom Gilb is firmly in the numbers and metrics camp and argues a good case for measurement and targeting. I was lucky enough to spend lots of time listening to Tom and talking to him.

It seems that, as with so many other things in life, the key is doing it right. It is very easy to set the wrong targets, to measure the wrong thing and produce side-effects you don’t want. But when you look at the right numbers, measure the right thing, and set the right targets you can get great results.

But it isn’t easy, most people get it wrong.

Tom is a fascinating guy, if you ever get the chance to hear him speak do so. A lot of his ideas come directly from Deming – who he knew personally. I don’t think it is too much of an exaggeration to say Tom may be the Software World’s own Deming. If nothing else Tom interprets Deming’s message for software development.

Software development success

In an aside Tom also pointed out that the UK now has Royal Academy of Engineering and that they (not so) recently produced a report on software development. Its a shame that you can’t down load the report, I’d like to read it.

I notice the comment that “only around 16% of IT projects can be considered truly successful”. That 16% seems very close to the figures given in the MIT Sloan Review piece on the IT alignment trap last year. That report said 7% of companies had effective IT departments which delivered on business objectives and another 8% who were effective but were not aligned with the business.

Unfortunately that means 85% of us are working on failing projects. Depressing.

The 1968 wrong turn reconsidered

I’ve been heard to say that somewhere about 1968 the software industry took a wrong turn. We went down the route of engineering, planning and tools rather than people and learning. But the conference made me wonder, maybe it wasn’t such a wrong turn, maybe it was a diversion we needed to take so we could solve some problems. Now those problems are kind of solved we need to refocus on the people.

Maybe.

Product Managers

I have long claimed that UK business do not get Product Managers, this might now be changing. The term Product Manager was in wide use and more people seemed to have a Product Manager on their team.

Lets hope I’m right.

Still, there are too few Product Managers, too few of them are really good, their role is still misunderstood and there is not enough training for them.

Next years conference

I’m no longer on the committee for the conference but I still have conversations about it. It is already taking shape in peoples heads and promises to be an even better conference. For better or worse the conference is unlikely to get any bigger. If it were to get bigger it might loose some of its flavour.

I think the next 2-3 years will be an interesting time in the UK and European conference scene. The arrival of the profit making QCon is having an effect and I know there is some debate about the future, style, content and so on of other conferences. At a guess I think you might see one or two new conference appear and others (perhaps) disappear or change.

My book

It was good to see Changing Software Development selling, and fun to sign copies!

Latest figures say it is selling well, yippee!!!

This Blog

I met several readers of this blog at the conference. Seems they want shorter entries. I’ll try my best. But I’ve said this before and failed!

More comments on ACCU conference Read More »

400px-Standard_deviation_diagram.svg.png

Implications of the Power Law

Agile / / / 1 Comment
I’m trying to capture all the thoughts triggered by the SPA conference before the ACCU conference in a couple of weeks time. One of the topics that resurfaced at SPA was the Power Law. Or rather, the fact that software source code and program execution follows a Power Law distribution. If you’ve not come across this before it is worth knowing.

Most (educated) people are familiar with the standard distribution, or bell curve. And the idea that most values cluster around a mean with most data falling inside a standard deviation. It looks something like this:

(Thanks to Petter Strandmark and Wikipedia for this image.)

Well there is another distribution which is called a Power Law distribution. It looks something like this:

In other words there are a few very large numbers and lots of very small ones. Most values are small, if you calculate the average its going to be small because there are so many small values the few large ones get averaged away.

As a result you get the long tail that seems to get so publicity. The 80-20 rule, also called the Pareto Principle is an example of a Power Law but this is a relatively mild form. Some distributions may be 90-10, 99-1 or even higher.

Well it turns out that software follows this distribution. If you take a source code base and count the length of each function you will find a few long functions and lots of small functions. Perhaps not every time but in general this is the case. (I’ve been told this several times and believe it, but I can’t put my hands on an reference to prove it, if anyone can please let me know, more importantly if its been disproved please tell me!)

It also turns out that program execution proceeds in a similar fashion. A few functions account for most of the execution time. Not necessarily the long functions I just mentioned, they could be short.

And it turns out that object graphs in OO systems follow the same pattern. James Noble has some work on the power law in Java systems – systems which conform to the power law are said to be scale free. As this paper points out the web itself conforms to this law.

I’ve been thinking about this for a few years – every since Kevlin Henney and James Noble explained it to me in fact! – and SPA gave me another boost when Michael Feathers mentioned it again. This actually has some quite important implications for software development.

Obviously this law has implications for performance optimisation: find and optimise those few functions where the time is spent.

It explains why major bugs can remain hidden for years and years. Because they exist in a function which is very very rarely used. The program crashes very occasionally. Of course if way the program is used, or the data changes, you might start triggering the bug far more often.

Most changes to a system will occur in a few places. Most of the system will remain stable and unchanging. Therefore it makes sense to refactor those parts of the system that do change and leave the rest.

Perhaps most importantly this law also completely demolishes the argument that you can’t retrofit unit tests to a legacy system. I regularly meet teams who say: “We agree that automated unit testing is good. But our system has 1 million lines of existing code and we can’t cover it with unit tests.” They then usually continue: “Therefore we can’t refactor or apply any of the other principles of Agile development.”

But when I have worked with teams that start to add unit tests to a legacy system they quickly find the tests pay for themselves. Even with a few tests in place there is a pay back. The power law explains this: because most changes happen in a small amount of code, putting tests around that code now will benefit you very soon. Most of the system is not changing so it doesn’t need tests. Of the 1 million lines perhaps only 10,000 changes regularly. As soon as you have 1,000 covered you see the pay back.

It is difficult to know in advance which parts of the system need tests so you might as well add them to anything you are working on. Just because this code hasn’t changed in the last year doesn’t mean it won’t change again soon. The fact that you are working on it shows it is more likely to change than most code. Save your time guessing what will change, just test it.

I’m also starting to see the Power Law elsewhere. It has long been noted that some developers are far more productive than others. 10, 20 or more times productive depending on who you read. Is this another Power Law at work?

I looked over the blogs (of individuals) I subscribe to on Bloglines this morning and made this graph:

This is the number of readers subscribed through Bloglines to the blogs I subscribe too. Joel Spolsky leads with 43,000, Robert Cringely weight in at 19,000 and Guy Kawasaki is a distant third at 3,300. Most of the blogs (including this one) are in the long tail with less than 10 readers.

I think I also see the Power Law at work in employment of IT people. A few people stay with a company years and years and years. Most other people average 18 months or so. Apparently once you’ve been somewhere for 7 years your chances of changing employer drop to near zero.

Some features in a program are used so much more but at the requirements stage it is difficult to know which these are and which are in the long tail. So the Power Law is at work in requirements too. The trick is to work with the law rather than against it: us a little-bit-and-often development and release strategy. Don’t front load your projects with requirements. Do a little, release a little.

It seems the Power Law runs throughout IT, unfortunately many people have internalised the standard distribution and use this as the, sometimes unconscious, basis for making decisions. Decisions made on a standard distribution are wrong. We need to learn to think in Power Law distributions.

Implications of the Power Law Read More »

Agile software development with Kanban

Agile / / / 2 Comments

A lot of people in Agile circles are talking about David Anderson’s Kanban software development technique. To be honest I’ve looked at some of David’s online material and I haven’t really seen anything that new. But then, I’ve never spoken to David or seen any of his presentations.

So I took the opportunity at SPA to ask Steve Freeman about it. Unlike me, Steve has spoken to David so here are some of the points I got:
• Kanban teams have given up on planning and estimating entirely. The activities took more time than they were worth. Prioritisation is – as far as possible – handed back to the business. The highest priority is simply done.
• Kanban teams have a number of ‘slots’ by which I think they mean ‘tasks they can be working on at one time’. The business decided what to put through these slots.
• Teams track how long it takes for a piece of work to move through the system. I guess they just note the start date and end date. They can then tell what their throughput is which replaces the need to estimate.
• Work is tracked by cards on a board. This visibility together with the flow measurement helps show where the bottlenecks are.
• The business may (i.e. not all teams do this) offer the business a ‘Silver Bullet’. The business can use this to cheat: to fast track a feature through the system, to do a feature without any of the usual pre-work, or such. However, the business is only allowed one Silver Bullet at a time.

It all sounds very interesting and I hope to hear more. And if anyone reading this knows any more – or thinks I’ve got something wrong – then please add your comment.

According to Steve, David is finding that his bottleneck is not development. The bottleneck is earlier, its with the business deciding what to do and what needs to doing. This is something I have observed myself. In fact I thought I had written a blog entry on this subject, perhaps with the title ‘The Bottleneck has moved’ but I can’t find it so probably I haven’t written it just thought about it.

Anyway, I’ll say it now: The Bottleneck has moved.

In my own experiences with my Blue-White-Red agile method, I found that while it took time for developers to do work this was simply leg-work. More developers more work. Quality improvements (unit testing, code reviews, etc) helped and these made the teams more productive. But when ever the developers needed to consult the business (i.e. product management) things slowed down. Or, developers took the wrong decision and re-work resulted.

And if we want to practice Lean development then we can’t waste time building the wrong thing. We need the business to support us.

Over the last 20-30 years developers have got a host of new toys to make them more productive: their own (fast) machines, more productive languages, nice IDEs like Eclipse, and so on. Surely some of this technology has boosted their performance. On the other hand, the pipe coming into development hasn’t go any bigger. If anything it has got smaller.

What strikes me about Kanban is that it requires more business buy in, more business acceptance of the method and requires the business to know more about its role and what it wants. This is good because it makes development more responsive to the business.

This is entirely what I would expect because, while Agile/Lean can improve development alone, it ultimately needs to exist in an Agile/Lean environment. If it does not there will be tension, eventually the organization will kill its Agile development or Agile development will infect the wider company. This might be what David is seeing (or creating!) with Kanban.

Agile software development with Kanban Read More »

Lean Product Development references

Uncategorized / /

After yesterdays blog posting I had a comment from ‘Brave Heart’ asking for some references on Lean Product Development. I’m more than happy to help and normally I’d reply direct to Brave Heart. But… I can’t find your e-mail address on your posting or blog. So that means everyone is going to see my recommendations…

The only book I’ve read which is dedicated to Lean Product Development is Michael Kennedy’s Product Development for the Lean Enterprise. There is some additional information in Machine that Changes the World (little bit dated now), Lean Solutions and Thinking Beyond Lean (also getting a bit old) but not a lot. I believe there are a couple of other books dedicated to the Toyota Product Development System but I haven’t read them.

I think you would benefit from looking at some of the literature from the software community. In particular Mary and Tom Poppendieck’s books Lean Software Development and Implementing Lean Software Development.

From there you have to decide if you want to look at Agile software development. I think of Agile as an application of Lean, which I talk about in my own book, Changing Software Development. If you do then SCRUM is going to be of more interest than XP or some of the others.

This is because SCRUM has its roots in the knowledge management – specifically the theories of Nonaka – and these link up with the knowledge thinking behind Lean Product Development. Which brings us full circle back to Kennedy. As Kennedy points out, Lean Product Development might be better described as Knowledge Based Product Development.

As for research, you might want to go and watch some Agile or Lean teams in action. Its probably easier to find teams which consider themselves Agile than Lean. You’ll want to look at how their activities differ from ‘traditional’ product development.

I hope that helps.

Brave Heart, please drop me e-mail (with your address) if I can be of any more help.

Lean Product Development references Read More »

News, Conferences and a Project Management revelation

Agile / / / 1 Comment

This blog has been rather quiet for the last couple of weeks, and most likely it will be quiet for the next couple of weeks. This hasn’t been for a lack of interesting things to say, quiet the opposite. In the last few weeks I’ve had insights coming left, right and centre. However, I haven’t had much time for blogging.

As I said at the start of the year I want to divert more of my writing into other projects. So this entry is here as a place holder and a preview of some stuff to expect. So please forgive me for breaking my one entry, one idea rule.

Those of you who know me off-blog will know I spent most of last year working with an Internet TV (IPTV) technology company. Some consultancy actually continued into the year, mainly with the CEO. Well now I’m please so say I’m going to get involved in IPTV again. I’m going to be doing some work with one of the major players to developer a completely new IPTV platform. Should be fun.

After XP Day last year I suggested that media companies are more open to Agile methods many other companies, specifically, banks. I am more and more convinced of this fact. Underpinning this is that fact that companies that use the traditional (broken) methods are still in business, these methods have brought them some success and fit with their business model – or their business model has been changed. Therefore these companies have little reason to go through a difficult change.

At ACCU London last month someone asked me: Why do banks have so many bad systems? It was that moment I realised: Because they can afford it. I hope to expand on this topic soon.

I’ve been busy with EuroPLoP 2008 and I’m at SPA 2008 next week, both look like being a good conferences. Then I’m at ACCU 2008 a couple of weeks later. Both of these will produce some reflections in this blog.

I’m going to be writing more about Project Management in the near future. Readers of this blog, and those who know me, will know I have been critical of them in the past. And I promise to carry on being so. But…

During the last two week I have taken Project Manager training, not just any training, PRINCE 2 certified training. Yes you read that right. Barring any surprised form the exam I took today I expect to be PRINCE 2 certified in the next few weeks.

So, why did I do it? Did I have a labotomy? Well it wasn’t an easy decision to spend nearly £1500 on the course but here’s why:
• I’ve criticised Project Managers in the past but this has been unfair, I haven’t really known what they should be doing, only what they do
• Increasingly I find that I’m asked to do Project Management roles, so the training should help there.
• More organizations look to PRINCE 2 to show you know about Project Management. To impress them you need to tick that box.
• I’d really like to understand how formal Project Management compares to Agile, and whether it is possible to bridge the divide.

I’ll write more about this soon but some immediate thoughts.

I had to do two courses for two exams, one last week and one this week. Consequently I’ve met over a dozen other people taking the same course and exams. Almost everyone of these people was an independent (contract) Project Manager in the IT sector. They were sending their own money to go on the course, and foregoing even more money by being there. Why?

Because increasingly PRINCE 2 is becoming a necessary qualification, if you don’t hold it your CV won’t get beyond the recruiter or HR department. PRINCE 2 fans are probably delighted to hear that. PRINCE 2 is wining! But actually I think its a very dangerous development.

This is because PRINCE 2 is massively risk averse. Of course PRINCE 2 practitioners would probably say “No its not, it just identifies and managers risk, you decide the risk level, isn’t that sensible?” but actually the very mechanism is risk averse.

Why is this dangerous? Because most companies – unlike the Government who developed PRINCE 2 – want to make a profit. Economists tell us “Profit is the return for Risk”. So, remove the risk and you remove the profit… more on this shortly.

Interestingly nobody on the course expected to actually use PRINCE 2. Even those sent by their companies (about 2) didn’t. So I don’t think PRINCE 2 is increasing in use, its just the qualification that is being asked for more and more.

Second insight. PRINCE 2 is not reflective, it considers the cost of projects, the cost of work but not the cost of itself. To run a full blown (or even half blown) PRINCE 2 is going to cost you a lot in administration and paperwork. That’s before you count the missed opportunities.

A few years ago I found myself introducing Agile at a company which hired a PRINCE 2 manager. We didn’t get on. We were both trying to do good for the company, and in many ways our prescriptions matched but … well I’ll explain where PRINCE 2 and Agile match soon, and I’ll explain why they are incompatible too.

Somehow I got cast as the zealot. Some people came to believe that I wanted Agile, Agile, Agile. He never got cast as a zealot, that only dawned on me this week. Actually advocating PRINCE 2 and its practices the way he did was every bit, more so, as zealous as I was. But…

PRINCE 2 is so respectable nobody will call you a zealot for advocating its use. Its like suggesting you play Bach or Mozart. How can anyone object? Its respectable. Agile on the other hand is punk, its putting a safety clip in your nose and taking risk. No wonder I was seen as the bad guy! Now, once my certification comes through….

News, Conferences and a Project Management revelation Read More »

High Church, Second System effect and re-writes

Agile / / / 1 Comment

After ACCU last last Thursday I was in the pub with Bronek Kozicki – and many others. The subject of system re-writes came up. This is a perennial subject, for example have a look at Alan Griffith’s Overload 79 editorial or Tim Penhey’s CVu editorial from the same month.

Recently I’ve been consulting with a company which has a truely awful code base. The developers want to re-write it, naturally. Unfortunately the the code base isn’t the only problem, the company has other problems and matters aren’t helped by Kissinger-esque linkage with other issues. I’m not going to say anything else about them except to say Conway’s Law was clearer than ever.

And its not just software people who stuggle with the question: Is it better to re-wright, or not to re-write? This piece from last week’s FT shows English lawyers and tax authories have the re-write problem.

Bronek sent me a link to Portrait of a Noob by Steve Yegge – not a blogger I read but I’ve been sent several of his posts by people in the past so I know of him. In many ways I find this reminiscent of my own High Church C++ pieces from a few years back. Both pieces point out that quality code is subjective, what you think of as good code in one context is not the same as what you consider in another context. Steve is right to point out that your persepctive on code changes. In particular, as you get older and acquire more experience not only does you coding style change but the way you approach problems changes.

As someone pointed out on Thursday night, you also need to remember Fred Brook’s and the Second System Effect:

‘This second is the most dangerous system a man ever designs. When he does his third and later ones, his prior experiences will confirm each other as to the general characteristics of such systems, and their differences will identify those parts of his experience that are particular and not generalizable.

The general tendency is to over-design the second system, using all the ideas and frills that were cautiously sidetracked on the first one.’

I’ve long wanted to conduct a little experiment. Take a developer, take a system he developed in the first few years of his life. Wait long enough for him to forget the details, say 10 years. During that time let him learn, gather experience and continue developing systems. Now ask him to make changes to the system from his early years – with all the identify removed of course. My theory is, he will proclaim it unmaintainable and in need of a rewrite.

That is a little unfair actually because one of the things you learn as you get more experience – OK, get older, lets not beat around the bush – is that all systems are maintainable. The other thing you learn is that rewrites usually end in failure.

Our education system has it wrong. At school and college we learn to new write new code. But most developers spend most of their time maintaining old code. Our education trains us to believe a lie, that we write new systems. For the first few years of a graduate engineer’s career he is disappointed, he searches for ‘green field’ development and faced with an old system he throws his arms up – ‘Re-write! We must re-write!’

Not only are young developers sadly disappointed by the state of the world they are a risk. Sometimes people believe them and let the re-write the system. (Believe me, I was once that developer. I persuaded my employer to let me re-write a system. It was a mistake. )

Colleges need to recognise this and start setting assignments were people must maintain code written by others. Systems should be handed from one year to the next for changes.

As a developer gets more experience they learn how to work with existing systems, when to re-write parts and when to work around. The hallmark of an experienced developer is that they do not jump to say ‘Re-write!’ – they can at least present options.

In fact, the hallmark of the best developers is that do work with legacy systems. Anyone can write a new system, we get trained for it in college, its what the books describe, there are few limitations. You can create your own mess, and you usually know your way around your own mess.

But the best developers can work with someone else’s mess and still find gold.

High Church, Second System effect and re-writes Read More »