Monday, September 12, 2016

Conclusion: Agile & ERP, part 5

The story so far…

  1. Agile & ERP?
  2. The Good News about Agile & ERP
  3. ERP Culture v. Agile Culture
  4. Th Bad News about Agile & ERP        5.        

Where does this leave us?

For a modern software developer, who understand agile and is well versed in the current ways of working encountering an ERP system is like stepping back 20 or perhaps 30 years.

The mindset of in ERP is more akin to the software development mindset when I started working in IT. It is as if the last 20 years have passed them by - the technology is dated, the agile revolution hasn’t happened, users should be grateful for what they are given and the vendor is all powerful.

The deal with ERP is: the ERP system does so very much, why reinvent the wheel? Writing software is expensive (and fraught with failure) so why not use one we made earlier?

It’s the software reuse argument written BIG.

The downside is: the ERP is all encompassing, you need to use particular technologies and these technologies haven’t really advanced in 20 years. The skills are in short supply. Most importantly: all the ways we have found to make software development more effective are absent.

Let us be very clear: there are massive benefits from using an off-the-shelf system. ERP systems are big, really big, and complex, general ledgers, multi-country/multi-currency payroll, etc. etc. Why would you want to rebuild this stuff?

But: there are also massive costs.

The ultimate question is: are the benefits greater than the costs?

Its worth repeating what Capers Jones says at this point:

“As a rule of thumb, if COTS [Common Of The Shelf] packages require modification by more than 25% it may be less expensive in the long run to build the same kind of application.” Applied Software Measurement, Jones, 2008

Unfortunately he doesn’t elaborate on how the 25% is calculated, he probably means function points. He continues:

“Package modification is a high-risk activity with a significant chance of failure and disaster. Not only is productivity normally low for modifying purchased packages, but if the vendors are reluctant to provide support, modification can easily be more expensive than customer development.” Applied Software Measurement, Jones, 2008

When answering this question please remember licenses for ERP systems are far from cheap, and they reoccure. Plus, vendors may well charge extra fees to support parts of the system which have been changed or to ensure backward compatibility.

Once installed clients can be very, very, reluctant to update ERP system. This is hardly surprising once you realise that “configuring” a system like SAP may mean having developers change SAP code in the base system. If SAP release a new version they may have changed that code, you are lucky if you can get away with a merge from hell.

When you buy an ERP system you buy an existing legacy system. You then attempt to configure it to be your legacy system. (See my Peugeot post.)

This sounds like a bad deal but its a deal that makes sense for a lot of companies and has done for 20 or 30 years.

Now, here is my conclusion:

20 years ago buying a legacy ERP system and configuring it to be your own legacy may well have made financial sense.

But in the last 20 years technology has advanced, not just the CPUs but the programming languages, the programming tools and even the programming processes.

Buying a legacy ERP system today means buying into a legacy development process with legacy tools. You step back 20 years.

In the last 20 years the tools and techniques have got a lot better. While buying an ERP system may look like a sensible decision you also shackle yourself to 20 year old tools and processes.

The tools and processes have improved so much in the last 20 years that the equation has changed. Modern approaches (i.e. agile and test driven) using modern technology means the cost and time gap between a) developing your own system using modern techniques (including microservices, existing libraries, open source, etc.) and b) choosing legacy ERP system (reoccuring license fees plus configuration costs) is far smaller than it was.

I conjecture that the gap is getting smaller as we speak.

Since ERP systems last decades the 20 year old ERP system you are buying today might be expected to last another 20 years. Who knows how much better things will get in two decades.

This also means there is a market opportunity for “modern ERP” systems which use modern technologies (Java, JavaScript, Micro-services, etc.) to support modern working practices. Microsoft, Oracle and SAP are all trying to move forward but the legacy is very profitable.

Finally, one might ask: given all these problems, and the changes in technology why do companies buy these systems?

Nobody ever asked my opinion on this so I can’t really say but let me float an idea.

Only companies of a certain size, say $1 billion revenue can afford these systems. When a company reaches that size they are expected to buy such a system - having an expensive system is a sign that your company has arrived.

These systems are driven by the finance departments, the CFO. As companies get big they need such systems to control the company. But also, the CFO of a $1bn company wouldn’t look serious if he didn’t have one - after all, all the other $1bn companies have an ERP system so why not yours?

If you are the CFO of a $1bn company without an ERP system and something goes wrong it will look irresponsible. Having an expensive ERP system allows the CFO to say “We followed best practice and bought Oracle”. It reduces the risk of the CFO losing their job.

And buying an ERP system allows the CFO to claim more resources for his department.

And it allows the CFO to say at his next job interview “I introduced an ERP system to a $1bn company.”

So the next time you get appointed CFO of a company which as just broken the $1bn revenue barrier and you find there is no ERP system in place what are you going to do?

Engineers might think: I’ll set up a small team and start growing our own ERP system using modern technology.

To the engineering mind that approach stands the best chance of working and is financially the best route.

But it is also high risk simply because nobody else does it.

Everyone else says: “I’ll call SAP, I’ll spend a lot of money with them, Accenture, Cap-Gemini and CSC. When it goes wrong I can blame them. After all, thats what everyone else does so doing anything different would be high risk.”

Friday, September 09, 2016

The Bad News: Agile & ERP, part 4

The story so far…

In this mini-series I’m discussing Agile development on ERP systems. If you are doing this and you’ve just Googled “Agile and ERP” there is a good chance you’ve found this blog because… bad news… there isn’t a lot of experience of doing Agile in an ERP environment.

Sure people have done it, sure some people have written about it in blog and journals but I said: “some”. Some means “not many”. One of the problems of doing Agile in an ERP setting is that there is a lack of knowledge and experience. People have done this, I’ve “done” it several times myself but… not as many people have done Agile in ERP as have done, say, Agile in Java Banking or some other domain. And very few of them have written their experience up. And even fewer have good stories to tell.

Partly it comes down to a question of “What do you mean by Agile?”. Sure you can do Agile in ERP if you define “Agile” as those “agile” practices which work in the ERP setting. On the other hand, when you do find the examples that are out there you will find many practices missing, specifically the technical practices.

Almost all the reports of Agile in ERP you will find are about process - much like my previous post . Doing ERP with test driven development, acceptance test driven development, simple design, emergent design and refactoring is almost unheard of.

Sure there are a few blogs out there which discuss it a bit but there is not much. I briefed a recruiter to find someone with (A)TDD and ERP experience. He came back a couple of weeks later and said “Its like looking for Unicorns, these people don’t exist.”

In part this is because ERP systems are sold on the promise of EVERYTHING. Their design dates back decades so they are monolithic and the culture that surrounds them is 20 or 30 years behind the current thinking.

My most recent run at this problem was the best yet but here is the bad news: with an ERP system once you move away from the Agile processes practices and start to look at the Agile technical practices things get very difficult.

The cultural problems (corporate IT and ERP specific) don’t help but the technology is the major obstacle. Lets start with testing…

Some test frameworks do exist (e.g. ABAP Unit and X++ Unit) but they are limited and, as with other languages, only a fraction of developers use them, and only a few of them do it properly.

One of the problems is an old one: Mocking and Stubbing. But in an ERP system the Mocking and Stubbing problems are far far worse because the system is provides so much already you need to do more mocking, the system is pervasive, there is just more system to mocks and stub.

Since ABAP is effectively Cobol you can forget reflection, annotation and polymorphic substitution. Heck, I don’t think it even supports macros!

Part of this problem is because of the architecture of ERP systems. The architecture is decades old, its decidedly not Object Oriented, as closer to working in embedded C than Java.

Another problem is because of lot of the system isn’t programmed in text. Remember I said some of the programming was table based? And some was pointy-clicky? That stuff is super difficult to test because it exists in a different paradigm. In some cases even when the “configuration” exists as a code like fragment it is considered data by the system and cannot be extracted.

In once case we exported “the code” only to find it wasn’t coded in ASCII. And if you’ve exported it you might not be able to import it again.

The designers of these systems actually expect their production code to be changed, tinkered with, messed with, hacked, by those configuring the system. Let me repeat: production code from the vendor may be changed as part of a configuration effort. Imagine that when you wanted to write a macro in Microsoft Word VBA you were allowed access to the underlying Microsoft Word code.

These systems are the exact opposite of what John Vlassides would advocate:

"the hallmark of good code is that it is changed by adding to it, not hacking it" John Vlassides, The C++ Report

Changing code by adding to it is a new idea in the ERP world, both for those “configuring” it and those building the product.

But the problems of Automated Unit Testing TDD pale into insignificance when compared to the problems of doing automated Acceptance Test Driven Development (ATDD).

Because ERP systems are monoliths it is hard, if not impossible, to find a way in to add ATDD style tests. These systems don’t just predate microservices they predate components, COM, CORBA, DLLs, shared libraries and even static libraries.

I’ve seen automated test tools work at the highest level, the UI level. I’ve heard Quick Test Pro can run against the UI on Windows interfaces and I’ve seen Selenium run against a Microsoft front end, I’ve even seen Selenium execute a Given-When-Then test but…

This is all at the UI level.

It seems impossible to set up tests anywhere between the very lowest level and the very highest.

If you are lucky the ERP system exposes some services or interfaces you can connect to, for example Rocket U-2 lets .NET code connect to it in places. But such interfaces are not always there, or if they are they are undocumented and subject to change. So most higher level testing needs to be at the UI level….

Since its at the UI level the tests are slow, fragile, slow, difficult to create in advance and slow; the whole system needs to brought up to run them so if something is found its a big pond to fish in.

Since the whole system is being powered up for a test you need test data and this is a problem. If you are very lucky you might be able to get to a relational database and insert your own data, if you are unlucky you won’t be able to access the database or you’ll find its an old propriety hierarchical database and you will need to load lots of data.

And did I mention its slow?

It is not just ATDD tests which are slow the build is slow too. Hours not minutes.

Building might not be much like you know it, I once had to explain source code control to an SAP team. Because all configuration is considered “data” the very idea of source code control can be strange - you are dependent on the vendor actually supporting source control which at one point SAP did not.

Sometimes actually saving “configuration” and loading it into another instance of the system isn’t supported to start with. You may need to build that plumbing.

And remember, these ideas may be completely foreign to the people “configuring” the system. These people are HR or supply chain experts who happened to pick up a bit of ERP and found it pays well. They don’t understand many software engineering concepts, they may not particularly want to learn them and their employers may not want them to either.

As I said before: these systems are large monoliths.

Many of the tools and techniques which software developers have created to manage large systems, to modularise them, to control them, to isolate parts of them, to allow change at different rates are simply absent. ERP systems are not just monoliths the are monopolies, they are intended to form the central nervous system of an organization and run the organization, they are a single thing.

That is their nature, their culture, their technology, even their raison d'ĂȘtre.

That might seem strong but think about it… Senior managers buy these systems to provide insight and control over large organizations. They want the large organization to function as a single entity, they don’t want duplication, they don’t want variation, they want a monolith and that is what the ERP sales people sell them.

So while you might be able to bring some Agile to ERP implementation there is a very deep seated conflict between the agile means and the decidedly non-agile end.

Thursday, September 08, 2016

Culture problems: Agile & ERP part 3

I suggested some cultural problems with software development in an ERP setting in my second post on Agile and ERP, this time I want to look more closely at the differences in the two cultures.

Many of the cultural issues revolved around the fact that ERP tends to happen in a corporate IT environment, and since corporate IT is a more challenging place to develop software anyway an ERP system is going to have “the usual” corporate IT problems.

However ERP systems seem to be prone to even more cultural problems.

I’ve already said that ERP systems are monoliths, and I’ve also hinted at the fact that they are hierarchical in nature. In part this is a historical hang over, they come from the Cobol mainframe world when systems were written like that.

If you know Conway’s Law what I am about to say is obvious: organizations developing, sorry, configuring, ERP systems are themselves hierarchal and monolithic. Separating the HR development from the Logistics development is hard.

This is actually a great example of Reverse Conway’s law (sometimes called Yawnoc): the organization is a copy of the system architecture.

When an organization buys an ERP system they buy a large, monolithic, hierarchal system, the investment (financial and personal) required from senior managers mean the homomorphic force is strong. Therefore the organization which engages with the system becomes a copy of the system - reverse Conway’s.

(On the bright side, since these systems are designed to serve yesterdays needs using technology based on yesterday’s paradigms there should be an opportunity to disrupt this model - but that is another topic for another day.)

Lets talk about some details…

The first problem hits you right out of the box, literally.

An ERP system is sold and marketed as an application which does not require programming, it only requires configuration. Take careful not of that word: configuration, not even customisation and certainly not programming. This is very sophisticated marketing.

ERP systems cost millions of dollars to buy and operate them. Very few technical people will ever have a say in the purchase of such a system. The sales people deliberately talk of such systems being configured (without programming) in order to say to the buyers “Look you don’t need any pesky (expensive) programmers.”

Instead they plant the idea that you install SAP, go to the tools menu, select options, choose the right tab, click on the box and … et voila! — the system is configured. OK, its a big system so it needs a “lot” of configuration but you get the idea.

This isn’t so.

The kind of configuration required by ERP system is far more akin to programming than any ERP seller would ever admit. It might not be the kind of programming recognisable to a Java developer but it is programming in a different paradigm.

Sometimes it is table based programming - a kind of predicate Prolog rules system.

Sometimes it is lots of parameters - think .ini or XML files but probably in some arcade syntax.

Sometimes it is quite literally lots of pointing and clicking.

And sometimes it is actual coding, usually in the systems only language, SAP uses a Cobol like language called ABAP while Microsoft Dynamics uses Frankenstein version of C++ called X++.

Note also, that because just about every ERP system I know of is actually an assembly of multiple different products built by different companies at different times and smashed together by the current vendor you are likely find all these approaches and multiple languages on the inside.

The first big problem to overcome when faced with an ERP system can be simply convincing people that programming is required. Or rather, that the kind of rules and thinking which apply to major programming efforts need to be taken here.

That programming is required is provable because there are always Testers. If configuration really was straight forward no testing would be required. Since ERP systems are always tested that which is called “configuration” is clearly more than tools, options, click. Clearly there is the possibility that two different pieces of “configuration” interact in unexpected ways.

Because ERP systems emphasis the business functionality and disclaim programming they claim to be configurable by practitioners, e.g. accountants, HR professionals, logistic experts. etc. Indeed you probably need to have domain skills to configure it but you also need technical skills.

Thus the people doing the “configuration” do not see themselves as programmers. They rarely have a programming background, concepts like cohesion, coupling, separation of concerns, interfaces, etc. are foreign to them and they wouldn’t know dependency inversion if it is turned them upside down - or any other pattern for that matter.

It is not that these people are stupid, actually they are experts in their own fields; rather because they do not believe they are programmers they take little interest in software engineering concepts. And since their education was in their expert field (logistics, accountancy, human resources, etc.) they they never learned these concepts at school.

Unfortunately when you program a big system, a big anything, having software engineering knowledge really helps - that is why the discipline came into being.

Worse than this, because the “no programming required” concept is encouraged by the vendors the programming systems inside the ERP systems also lack modern software engineering concepts. Remember: ABAP is Cobol, Cobol is not a modern language.

Like Cobol, ERP languages such as ABAP and X++ have a “commercial orientation” and lack the idioms required for engineering. On one ERP implementation I came to feel the whole thing was just Visual Basic on steroids - and VB6 at that! Such languages are Turning complete so you can do (in theory) do everything but somethings these things are damn hard.

The ERP culture creates other problems too.

There is no OpenSource for ERP. Nobody ever went home at night and wrote ABAP for release under the GNU license. As a consequence the kind of tools modern software engineers expect do not exist.

While ABAP-Unit and X++Unit exists they are not as widespread or as usable as JUnit.

Nor will you find Stackoverflow full of ABAP or X++ questions and answers. Sure there are a few but only fraction of what you will find for Python. To be fair, the number of ABAP or X++ programmers is only a fraction of Python, C# or Java programmers anyway so while some public resources exist there are tiny.

Many ERP “developers” work for system integrators (CapGemini, Accenture and countless small shops). They charge high rates for their people and take a very fluid approach to staffing. For example, an SAP HR “consultant” on a team I was working with had a two week holiday. The consultancy company sent another consultant to fill in for the two weeks she was away. I find it hard to believe the stand-in consultant could usefully do anything for the client in that time but by being there they could bill time for the system integrator.

A side effect of this is that the consultants are often in high demand, they may work on multiple client projects at once, and they are internationally mobile, they get lots of frequent flyer points.

This has some very practical limitations, these people may not devote 100% of their headspace to the client and getting a standup meeting to start early or at a regular time is hard it may depend on Heathrow congestion.

And because they work for someone else the client and the consultancy may not agree on who pays for any Agile training or workshops. I’ve found myself giving Agile workshops to client staff where the ERP consultants are excluded because they work for a supplier. Even when the client hires the staff directly, or the client and supplier agree, the ERP Consultants may resist learning about Agile, and especially technical considerations, because they do not consider themselves technical!

And when the ERP consultants do engage its is like stepping back 10 or 15 years, all the “old” arguments appear: “how can we do something in 2 week?”, “we must design the whole”, “the business must fix its requirements”, etc. etc.

In the next instalment we’ll turn to the bad news, the technology…

Wednesday, September 07, 2016

The Good News - Agile & ERP, part 2

First the good news: there is a lot of Agile practices which work just fine in an ERP environment. These are mostly the process practices and some from the demand side (i.e. requirements, “what are we going to build”).

All of the following work just fine and will improve work of teams in ERP:

  • Stand-up meetings work just fine, but stand-up meetings alone do not make a team Agile.
  • Iterations (Sprints) work just fine; and that includes starting them with a planning meeting and ending them with a retrospective. (You can do estimation with planning poker if you like, I’ve no evidence that it is accurate in this environment but it might be effective at persuading people you are taking estimates seriously.)
  • Visual boards work just fine and will improve work.
  • User Stories, i.e. small pieces of business valuable work, are fine; you can also use Epics and Tasks too, and you can do Xanpan style urgent-but-unplanned work too.
  • Defining acceptance criteria (conditions of satisfaction) works too.
  • Pushing authority down, encouraging teams to take on more responsibility is all good too. But note: ERP and big company culture make this a challenge
  • Agile Coaching works just fine too.
  • Product Owners work; and as usual in a corporate you will probably find a Business Analyst filling the role day to day. However, ERP culture is document centric and added together with authority problems means POs might not have, or at least feel they do not have, the authority to make decisions.
  • As always co-located teams work best, pair programming and mob programming work fine too.

Some practices are always more difficult, perhaps in ERP they are more difficult.

Identifying and delivering small, thin, slices of business functionality works, almost. Two problems appear. First because the nature of ERP systems is all encompassing business representatives are even more resistant than usual to accepting anything less than everything. Second, architecturally ERP systems do not lend themselves to working on things piecemeal. You can do some of this but its even more difficult than usual.

Emergent design is hard, largely because refactoring is still a new idea, the tools, techniques and most importantly mindset and understanding for incremental, evolutionary, organic style growth are not there. Therefore all the old arguments about “we must design the big picture” are very much in play.

Multi-skilled individuals and cross-functional teams: as with “normal” software development getting people to work outside their core skill-set helps smooth the flow of work; and as with normal software development there are limits to this both because of the learning curves involved and because of individual preferences and identity questions.

With ERP systems these issues seem to be more difficult partly because the skills involved in ERP work are even more different and - to preview something I will say later - there are greater cultural issues. Many ERP developers come from domains other that software engineering and therefore lack some of the basic understanding that one might expected of them.

Secondly, because ERP is normally done inside a corporate environment people are more conscious of their defined roles. In typical software companies individuals are more prepared to try doing something different because the aim is to ship a something. In all corporate environments people are more prone to limit themselves to their defined job roles and titles.

Corporate environments typically bring another problem too. Not in every case, but in the majority of cases, the quality (depth of skills, ability to learn fast, and such) of people inside corporate IT tends to be lower than that in specialist software development organizations. I tend to believe this is more a function of the organization than the individuals and it is not true in every case but it certainly seems that good technologists tend to gravitate towards specialist organizations.

This might be a function of recruitment practices, it might be a function of expenditure on training and skills, it might be a function of corporate mission, it may well be a function of the corporate environment or the specialist development environment, or something else altogether.

And because the corporate environment limits the teams ability to resolve impediments. Implementing a commitment model is extraordinarily difficult. This doesn’t worry me much because I’m not a keen fan of the commitment model anyway - see my Commitment Considered Harmful post.

The net result is: ERP teams don’t have as many high performing environment or individuals and teams as a specialist IT shop. (Obviously those two things go hand in hand but unravelling cause and effect is hard.)

And thats the good news, the next post will discuss culture before I turn to the bad news.

Tuesday, September 06, 2016

Agile & ERP? - part 1

This is the first of several blog posts about working in an Agile way with ERP systems…

Most of the developers, testers, BAs and managers I know have little, if any, awareness of ERP: Enterprise Resource Planning. The big software systems sold by SAP in particular but also by Oracle, Microsoft and others.

Strictly speaking ERP is a specific application for planning and scheduling resources usually in manufacturing, but many in the industry use the term “ERP” is used as a generic shorthand for a whole host of large enterprise applications beside strict ERP: CRM (customer relationship management), financial accounting, payroll, human resources, asset management, logistics and supply chain management, and more.

Over time the big players tend to have swallowed the more successful ones, so Oracle now owns JD Edwards and Peoplesoft, Microsoft swallowed Great Plains and Navision, The products tend get recycled… but I digress.

While most developers can happily spend their entire career avoiding these packages those that encounter them find two things. Firstly they very pay well, exceptionally well in some cases. Second these systems are all embracing: the database is probably hidden well down, it may well be hierarchical rather than relational; they usually come with their own language, SAP has ABAP and Microsoft X++

Over the years I’ve touched a few of these systems, some of the big names, some of the smaller names, some of the “modern” systems and some so old they predate the ERP classification - anyone for Rocket? Or Comet?

This year I’ve had an chance to work for an extended period with a team using Microsoft Dynamics and attempting Agile and I think its worth a few comments, partly about the state of “agile and ERP” but also about ERP in general.

In the next few blogs I’m going to say something about my experiences, I want to talk about the common issues with these systems, not specific problems of one team or another. Here are a few of the key-points:

  • Stepping into the ERP world from the Agile world is like stepping back 20 years, or maybe 30.
  • You can do Scrum in an ERP environment but it seems impossible to do XP, i.e. getting the technical practices to support your efforts does not seem possible.
  • Testing, automated testing is only possible in very limited amounts, its an uphill challenge.
  • Configuration is a form of programming but many people in the ERP space reject the idea that they are programming and therefore reject (or probably never knew) the engineering approaches that programmers (should) take.
  • Systems Analysts are alive and well in the ERP world: such analysts are rarely found in development teams any more, they role has fractured in two, some of the work has gone to Business Analysts and some to Architects and Senior Developers or just “the team”.
  • Release cycles are long and the monolithic nature of ERP systems means they resist attempts to reduce them. The monolithic nature bits these teams again and again.
  • Culture: the culture that surrounds ERP systems is the antithesis of Agile culture. In part this is because only large corporates have ERP systems; Agile can work in the large but it is more difficult, Agile can work in a corporate culture but it is more difficult, in ERP you start off down two and then you add ERP culture.

Reverse Conway’s Law means that the organizations which develop in ERP systems themselves take on the attributes of the system, namely they are hierarchical and monolithic.

ERP systems and Agile is a big topic and I’ve plenty to say so I’m going to blast out a series of blogs in the next couple of weeks, they are all drafted so watch this space:

(Update: having now published those posts I’ve updated these links.)

Thursday, August 04, 2016

Software development is upside down


In the software development world a number of common management maxims need to be reversed if one is to be an effective manager. Those who manage software development - and I include all the non-commissioned managers in this, Architects, Team Leads, Scrum Masters etc. - need to turn their thinking upside down.

Here are a few I spot all the time but I’m sure there are more:

  1. Diseconomies of scale: larger teams are less productive per worker than smaller teams, larger code bases are more expensive to maintain (enhance, debug, change) than smaller code bases per unit of code, large requirement requests (documents) are more expensive per request than small requests and so on.
  2. Higher quality is faster, there is no such things as “quick and dirty”: delivering quality work is faster than delivering shoddy work because shoddy work needs fixing. Even if the first low quality piece of work does arrive more quickly, the second will be take longer down because the first gets in the way. Each shoddy piece of work will cost more because subsequent work will take longer.

Software product has many “qualities”: functionality, speed of execution, usability, etc. etc. What constitutes quality varies from product to product however… all software products exhibit two qualities in common: number of defects (bugs) and ease of maintenance (maintainability). When I talk about quality it is these last two items I am talking about.

Whenever you find a high performing software team you find a high quality code base (low defects, high maintainability). Hardly surprising if you have read the work of Capers Jones and Kent Beck.

  1. Teams over individuals: There are times when a lone developer who can sitting up all night and deliver a world beating product. Particularly at the start of a new technology: think Nick D'Aloisio writing Summly, Matthew Smith writing Manic Miner, or Dan Bricklin and Bob Frankston writing VisiCalc in two months.

We admire people like D’Aloisio, Smith and Bricklin but they are poor role models. Most serious software development is a team sport. The characteristics which make the lone developer successful are a disadvantage. Managers who believe in the Lone Hero Developer model do everyone a disservice.

The constraint in developing software is not typing speed, it is thinking speed. We need people who can share, who can discuss, who can work together. That is why Pair Programming can be far more effective than solo programming and why Mob Programming is on the rise.

  1. Doing is the quickest way of learning: when processor cycles were expensive and difficult to get (think 1970, IBM mainframes, OS/360, IMS hierarchical databases and less than a dozen internet nodes) it made sense to think through every possible angle before developing something. Back then most systems were a lot smaller than they are today.

Today processor cycles are cheap, you have more CPU power in your pocket than Neil and Buzz took to the moon.

The quickest way to find out if a technology can do something, the quickest way to learn a technology, and the quickest way to find out what customers think is to just do something and see what happens.

There is a place for planning, but planning has rapidly diminishing returns. A little bit of planning is valuable, but a lot is counter productive: the return from lots of planning is minimal and it delays learning by doing.

  1. Do it right, then do the right thing: modern development is inherently iterative. If a team can’t iterate they cannot perform. If we are to learn by doing we must iterate: plan a little, do a little, review the results, plan a little, do a little….

“Customers don’t know what they want until they see it”

Or perhaps:

“Companies don’t know what will succeed in the market until they ask people to part with money.”

Again and again we see that customers need to be shown something in order to understand what a product can do for them. And again and again we see that until a product is in the market and customers are asked to exchange money for it the true value, the ultimate “doneness” cannot be judged.

Only when we are in the market, only by showing what we have, can we refine our ideas of what is needed and what is valuable. And when we have this information it is through iteration that we act on it.

If the team can’t iterate (do it right) then they have no way of learning and validating their plans. Sure, doing the wrong thing effectively is pointless, but the only way to find out what is right and what is wrong is to do something, anything, and iterate.

  1. Worse is better: the famous Dick Gabriel from 1989:

“the idea that quality does not necessarily increase with functionality—that there is a point where less functionality ("worse") is a preferable option ("better") in terms of practicality and usability. Software that is limited, but simple to use, may be more appealing to the user and market than the reverse.”

Sometimes creating a worse product is a more effective strategy than creating a better product. Building a better mouse trap is rarely the route to success.

To a business mind this maxim sometimes seems obvious but to an engineering mind it is shocking.

And this final maxim means that all of the above propositions are sometimes reversed.

(Many thanks to Seb Rose for comments on an earlier draft of this post.)

Tuesday, August 02, 2016

Zen'in keiei - more Japanese - every person a manager

There are a few words of Japanese that have permeated the lingo of Agile and Lean folk - Kanban and Kaizen being probably the two best know. Well, I recently discovered another one I think we should embrace.

A family friend works at Uniqlo in Moscow and I recently noticed a Japanese word on her LinkedIn profile and so I asked:

Zen'in keiei

This translates, broadly as: every person participates in decision making.

At Uniqlo - and it seems to be a Uniqlo only concept - this means "everyone manages", every staff member should be a business leader, act like owner, like manager, participate in decision making.

There are other explanations of this elsewhere on the Internet:

“Being the main players in the company, at all level” (Uniqlo values statement.)

“UNIQLO’s Zen-in Keiei philosophy, under which every employee adopts the mindset of a business manager, regardless of his or her position.” (Uniqlo HR documentation.)

“Zen-in Keiei: Everybody as a business leader...everybody should feel accountability and ownership as a part of UNIQLO” (Quizlet)

"One of the reasons for Uniqlo’s success in Japan is the notion of ‘zen-in keiei,’ which translates to “everyone as a business leader.” In Japan, people who are hired in the stores are told that they are a part of management, that they make very important decisions, and that they have the potential of making it all the way to the top. I think this concept is very foreign outside of Japan." Professor Hirotaka Takeuchi quoted on Reilly Brennan’s blog

Hopefully that give you a better idea of what we are talking about. I like the idea that everyone is in part a business leader and manager.

And look at that last quote, look at who said it, Hirotaka Takeuchi, better know to me as one of the authors of The Knowledge Creating Company and better know to many in the Agile community as one of the two authors of The New New Product Development Game.

I think this idea fits right in with how decisions are made in an effective modern (agile) software development environment. Its not about management, its about pushing authority and decisions down to the most appropriate level, and that level is the level the people actually doing the work - the people who are faced with the decision here and now.

These people need a decision now, and they have the most information about wha needs to be decided. Managers should be there to help them make good decisions not to make he decisions for them.

If this is good in a shop, in a retail environment, then isn’t it good for highly skilled technology workers?

This doesn’t remove the need for managers or management structures but it does change what management does - see my management series from earlier this year. And it also implies that many of those doing the work need more understanding of business and management and they need management skills - management for the masses!

Thursday, July 21, 2016

Magic software dust or a bashed up Peugeot?


Creating a new software application… is that a glass is half-full or a glass is half-empty thing to you?

Does the thought of actually employing programmers fill you with joy or with dread?

Get it right and software technology is magical, get it right and software technology can change the world.

The browser you are reading these words with.

The phone in your pocket.

The GPS signal which will help you go… well… anywhere!

Some technology is absolutely magical. And some software development teams are absolutely magical. They really can get things done - “hyper productive” as they say. The Alpha AXP compiler team (“commitment management”) or the Quattro Pro development team are two of my favourite better known teams but I know a few others who nobody will ever hear of.

Done right software technology is like magic dust, a little bit of software sprinkled about in the right place, in the right way and Magic!

But many, probably most, never experience this. Such people don’t know how good it can be.

The science fiction author Iain M Banks novel Excession is about an “outside context problem” - a situation which is so far outside ones experience that one cannot even start to comprehend it.

For people who’ve never seen a great software team it can be hard to comprehend what software development can be. The closest these people ever get it is using Google Maps on their iPhone to find a beer.

This is sad, so sad, because it colours peoples view: software development is seen as an expensive painful exercise destined to disappoint.

Most teams aren’t hyper-productive, rather than working on a mission to change the world they remind me of an old Peugeot 206 advert - its on YouTube:

If you’ve not seen it it goes like this: Man looks at a picture of a beautiful Peugeot 206 car in a magazine. He looks at his old heap… and then sets about smashing his car up, driving it into a wall or two, then setting about it with a hammer while people laugh at him.

At the end of the advert his old car kind of resembles the Peugoet 206 - it helps if you squint.

Unfortunately an awful lot of software teams seem to be stuck in this model. They seem intent on smashing something into the shape they want rather than building it right.

Things can be better, so very much better.

Those who believe software is a painful glass-half-empty exercise make it worse for themselves:

  • they try to constrain the builder by giving them a long elaborate “requirements” document
  • they sign contracts to protect themselves, they specify what, when, how much and even how
  • they drive price down because at least it if costs less the pain will be less which often means things end up in some cheap offshore location, out-of-sight, out-of-mind, out-of-control
  • they compromise on quality left, right and centre
  • quantity over quality is the mantra
  • and they blame the coders: after all, everyone knows they are a bolshy bunch opinionated overpaid factory line workers (think Red Robbo) who always mess up

In making these assumptions, in protecting themselves from these beliefs the glass-is-half-empty people create a self-fulfilling prophecy. Each and every one of these actions will make the development process worse.

On the other side, those who see magic at work see software development as a glass-is-half-full thing and will work with the team who understand what is needed, they will be flexible on expectations and they will understand that high quality is faster and cheaper, they will see the development team are experts in the technology and how the technology can deliver benefit.

This too is a self-fulfilling prophecy. Treat the team as adults and they will respond as adults.

Its up to you: your beliefs will determine the result.

Tuesday, July 19, 2016

Surge or pivot? - notes on failure

Failure is good.

We learn from failure.

Failure is learning; the information content of a failure may be more than the information content of success.

Failure isn’t failure, it’s an opportunity to pivot.

Failure is capitalism’s Darwinian evolutionary mechanism to remove the less productive, the less relevant.

Fail fast, fail cheap, learn, try again.

Creative Destruction is the way capitalism remove legacy companies to create space for the new by allowing resources to be redeployed.

All true… well at least to some degree but lets not argue about that today.

The problem is: How do you know you’ve failed?

Or to put it another way: What does failure look like?

Or: When do you know its time to pivot?

Some failures are clear cut: customers don’t buy your product, or too few customers buy your product to allow you to stay in the market.

Our software does not perform as expected, it doesn’t process transactions fast enough, or a rocket blows up.

As engineers we like clear cut failure and success. We look for clear failures or at least clear bottlenecks if only because we are certain they exist. But that isn’t always the case. Sometimes there are no clear success or failure states. And sometimes we don’t call it a failure because we really think we can make it work.

Rationally the business plan or strategy should allow us to know what success loos like and what failure looks like. But what if the strategy is itself flawed?

Flawed strategy might be obvious to one person but hidden to another. When strategy is flawed it runs like a fault-line under everything that is being done. One clue is that lots of little failures keep appearing, seemingly unconnected perhaps but actually connected because they are originate in the fault line.

(Think if this like a stack corruption bug, you don’t normally know you’ve got stack corruption but you get apparently random failures. When you chase these failures they move. Back when I was still programming I knew I had stack corruption because the fault moved every time I thought I was getting close.)

Even when surrounded by failure we look to explain it away, we believe (hope?) we can fix it - after all, we are learning from those failures and we are trying to fix them aren’t we? And people like me (consultants!) asked to help you address your problems and fix your faults.

But when do you call time? When do you say things are irreparable? When do you stop trying?

To use a better know example: When is a war won? And when is it lost?

In 1945 Victory meant the Allies taking Berlin. Once Berlin was taken and the genocidal Government was disposed the war was over.

In 1991 Victory meant retaking Kuwait.

Afghanistan 2015? - some say success, the west was victorious! and some say it was a failure. Failure and success is not clear cut. For the generals and politicians its hard to walk away from a failured war, far better to find some success, get out and disown the subsequent failure - like the 1973-1975 gap in the fall of Vietnam.

Since failure is not clear, and especially since victory could be grasped out of the jaws of defeat by calling in more troops, more consultants, better consultants, more expensive consultants how do we know it is time to pivot?

When do we pivot and when do we surge?

And since failure is still failure, and no matter how much we call it a pivot or repeat that we learn from failure we still don’t like it; when, o when, do we call failure failure and when do we call it pivot?

And like Generals, Senior Managers can’t walk away from a failure, that would be career threatening. Far better to surge, get to something which looks like victory, get out and disown what happens next. (If you are spending your own money you have an incentive to get out quick, if you are spending someone elses money…).

When pivoting is unattractive, when pivoting means people loose jobs, when pivoting means executives have to explain to their board, when pivoting means shaman consultants no longer take their cut… why pivot when you can surge?

Surge - call for help.

When we are failing without a clear cut failure we see problem after problem and each one is explained away.

When do you declare failure and pivot?

Undercover Economist Tim Hartford had a good piece recently: “You don’t know when to quit”. The true grit, carry on trying idea doesn’t seem to stand up to analysis. Rather than persevering at something difficult a better strategy might be to try something else.

The more money that has been sunk into the initiate the greater the difficulty in pivoting - nobody likes sunk costs, why sink the money?

For a Silicon Valley start-up living on credit cards illusions are painful, there can be very little tolerance for failure, failure must result in a pivot or death.

But for a corporation, for an established vendor, a brand, a reputation; failure might mean they are simply not trying hard enough - and heaven knows some companies tie themselves in knots. Why not through more money at the problem? More people, more experts - surge!

And so we are back to Do it Right and then Do the Right Thing (blog) (and Do Things Right Thing and then Do the Right Thing presentation.)

For a software team capability means: delivering working software. If you can’t deliver working software you have a clear failure. But if you are delivering software slowly, so, slowly, how do you know? What software developer or product manager hasn’t wanted to deliver more faster?

If you lack the capability to iterate then you can’t deliver.

If you lack the capability to iterate you cannot build feedback loops.

If you can’t build feedback loops then you cannot validate your market or your product.

If you can’t validate product or market then your strategy is high risk.

If your strategy is high risk then you really need a high pay-off to justify it. But if you can’t iterate then its likely your costs are going to absorb far more of that pay-off.

You might be able to buy victory but the price will be so high it is worth asking: is it a victory you want? Is it a victory you can recognise?

Tuesday, July 05, 2016

Using cost of delay to determine schedule

“When does the business need it?” is far more important than “When will the developers have it ready?”. Business needs should drive schedules, engineers need to create solutions which fit within business schedules. That does not mean cutting corners, it does not mean shipping with bugs or technical debt. Its the art of the possible and its what engineers have always done.

One of the tenets of #NoProjects is that work should be guided by business benefit, better still value delivered.

That very quickly means that one need to start talking about opportunity cost of delay. As I’ve said before, I don’t think “cost of delay” is the best name for this idea, (I’d rather it was called something like “benefit foregone through delay” but cost of delay is the name we have.)

Once one starts discussing business value and how potential revenue changes over time it very quickly becomes clear that business need and value should drive the development schedule not developer estimates.

Rather than saying:

"How long will X take to build?"

We need to be saying:

"Given that there is M money to capture, in timeframe T, what can we build for that much money in that much time and have a respectable profit left?"

Time and money are inherently linked. Everyone gets that more time creates more costs but fewer people get that more time probably means less revenue.

To put this more succinctly

"How much of X can we build in time Y and how much of the total potential value M will that capture?"

Lets me do an example analysts to show how a cost of delay analysis - with value estimates - can be used to substitute effort estimates. So here goes, I'm putting on my economist hat... lets set up the scenario…

Image its Christmas 2016, at one of those family gathering you see Uncle George who works for a successful start-up. George says the back-end he has been working on is great and has a nice REST API. The start-up wants to grow an ecosystem and the company is about to open the API up to third party apps. The startup will pay a small "finders fee" from 1 February for the first few months to each of these third parties for each customer they bring in.

Back in the office on 2 January you make some calls and find everything Uncle George said is true. In fact the start-up is falling over himself to help you, they are desperate for apps.

You have an opportunity. And you have at least a four week head start on any competitor.

Some quick "what if" calculations tell you there is €10,000 a week to be made. But you also know that competitors will come into the market the finders fee will decline. As you have a 4 week head start you probably have 4 weeks from the start of February before your revenue starts to fall off.

Some more analysis and you conclude competitors will steal increasing chunks of your revenue, you think it will decline €1,000 a week after February. Thus you can draw the following graph:


The blue bars show the weekly revenue. The red line shows the total lifetime revenue - the lifetime being from the start of February to early May. What happens after May is uncertain so to play it safe you have assumed no revenue at all.

The red line is important - note: this chart uses two axis, the one on the left is for the blue bars, the one on the right for the red line. The red line shows the maximum revenue you could make, it forms an upper boundary.

It doesn't matter whether you release your product tomorrow or 31 January, there is no extra revenue to be made during January. As long as you have a product in the market on 1 February you can start to capture some value. If you have a fully functional product then you can capture €10,000 a week.

Yes the delivery date is important, earlier is better, but so is the amount of product. Since revenue declines from March onwards delivering something smaller sooner may well make more total revenue than delivering more later. Less (functionality) may well mean more (revenue).

As you can see, releasing a product anytime before the end of January will result in €85,000 of revenue in total. After this the later the product is released the less revenue if will make. Your deadline is not a binary event, it is an elastic range of options which each produce a different outcomes.

Time is money but money is both cost and revenue: The longer you spend developing your product the greater the costs, but more importantly if the product is not in the market by 1 February you are loosing revenue. The longer you go without a product the greater the costs and the lower the revenue.

This is a simple model, like any good economist I have confined my analysis. I have assumed "all other things being equal", specifically I have assumed other competitors do not spot the opportunity before 1 February; I have assumed your product could grab the entire market on day-1 without a ramp up time; I have also assumed that even launching in March, when there are other competitors in the market you can still grab sizeable market share an day-1.

These assumptions do not invalidate the model. These assumptions may all be relaxed with a more complex model but the basic message will still be the same.

This analysis does not use any effort estimates. It does use value estimates. So lets now consider effort.

In the first instance, armed with this analysis, you go to you development team and instead of saying:

"How long will it take to build this?"

You say

"Given this analysis, what can we build in the next four weeks which can capture some of this value?"

It is not a question of: "Can you build X?"" but "What can you build in this time for this much money?"

Lets suppose you and the team quickly envisage a product, a product that can be rolled out in stages, say 10% per week. Even the first 10% will be useful. Lets assume a perfect correlation between the percentage of product built and the revenue captured and lets add this to the model.


Notice in this model it is impossible to capture all the €85,000 potential revenue because the product cannot be ready in full on 1 February. If you wait until the product is 100% complete before releasing it will be mid-March and you will only make €28,000 in total. This contrasts with the €64,400 you could make by launching with reduced functionality earlier, i.e. launching a smaller incomplete product earlier allows the capture of €36,400 more.

As I said before I could relaxed some of my assumptions and enhance the model but I’m keeping this simple.

You can also play what if games, for example, what if you halted development at the half way point?

  • If development halted at the beginning of February at 50% done
  • and the product remained in use until May
  • then it would generate €41,500 of revenue (64% of the total that could be made)
  • This does not consider the savings in development costs. Perhaps more significantly, the same people would be available to work on something with greater returns.

After all the product only has an anticipated lifespan of three months. Once March arrives the product revenues are falling, why would continue to invest?

There are many directions you can take this analysis and I’m not denying the effort and cost estimates have a role to play in the complete analysis. However benefit estimates and cost of delay analysis can be performed without any effort estimates, when value analysis is available it can be used to inform the effort estimation process.