The Chaos Factory

The inside story of corporate IT failure

ABOUT THE BOOK

Have you ever wondered why the website of your bank or phone company is so broken and unusable?

Do you find yourself asking: "How this can be"? What is wrong with these people? Why can't it just work?

Corporate IT departments are wasting billions of dollars on failed IT projects every year, and it has been this way for decades.

On top of that, consultants have extracted billions more from these companies with project management and methodology solutions that have quite obviously failed to make things any better.

This book, written by an insider with 30 years of experience in the trenches, explains the raw truth that corporate executives have been sweeping under the rug. With simple common sense explanations that cut through the typical gibberish that IT departments use to baffle and confuse, The Chaos Factory will explain in plain language how we got to the place where we are now, and what to do to make it better.

Business managers and shareholders alike will applaud this honest assessment that reveals the real root cause of IT project failure. They will be able to use the information contained in this book to protect themselves and demand better.

Adam

About Adam Z. Wasserman

With over three decades in the trenches of corporate IT, Adam Z. Wasserman has witnessed the evolution of technology from both sides of the fence—from Fortune 500 companies to cutting-edge startups. This unique vantage point has given him an unparalleled perspective on why enterprise technology so often fails to deliver.

Adam's track record speaks to his ability to see where technology is heading before others do. In 1984, he wrote his first commercial program. Two years later, he was architecting Canada's first ATM-over-fiber LAN implementation and the country's first industrial UNIX application for General Motors Canada. When the internet was still in its infancy in 1994, Adam made the prescient decision to build all his applications as web-based—a radical move that would become the industry standard years later.

His foresight continued when he designed and delivered a hosted Software as a Service (SaaS) platform in the late 1990s—a full five years before Salesforce.com would make SaaS the dominant business model. As CTO of the International Air Transport Association (IATA), he launched six successful online businesses between 1998 and 2004, proving that innovation could thrive even in traditional industries.

But it was Adam's return to corporate IT after a decade with startups that opened his eyes to a troubling reality: while technology had advanced dramatically, corporate IT departments had somehow gotten worse. The dysfunction, waste, and failure he witnessed compelled him to write The Chaos Factory—not just to expose the problems, but to offer real solutions based on decades of hands-on experience.

EXCERPT ONE

"In late 1988, Business Week published an article that stated a “survey of 600 firms indicated that 35% of them had at least one ‘runaway’ software project”[1]. Soon after, Dr. Barry Boehm, the Director of the U.S. Department of Defense’s Advanced Research Projects Agency published a series of articles about software risk management which further raised awareness about failed software projects.

The Project Management Institute (PMI) had been working very hard to elevate project management to a profession with standards and practices that could be considered equal to that of engineering. As part of this effort, studies were instituted on projects of all sorts, and for the next few years reports started emerging with statistics on software development project success/failure rates. They were not encouraging[2].

Finally, two very influential reports came out in 1994: The Standish Group’s Chaos Report[3], and KPMG’s Report on IT Runaway Systems[4], each of which independently surveyed large companies with large IT projects (in the US and the UK respectively). Both reported that in the opinion of the executives surveyed, barely a third of their IT projects could be considered definite successes. The failure of in-house custom software development projects was becoming well documented and corporate executives, especially executives of public corporations, were confronted with the responsibility of having to seek solutions to prevent the waste of shareholder’s money (estimated by both Standish and the PMI to be in the billions) as auditors increasingly focused on IT spending.

There were four different responses to this burgeoning crisis from four different communities: computer scientists (and software engineers), project managers, IT managers, and business managers. Over the next few chapters I will tell you about each one.

The academics, computer scientists, and software engineers naturally took scientific approaches: gathering data, proposing hypo­theses, and then testing them through experimentation. The result of this was an explosion of proposed methodologies claiming to address the root causes of IT project failures. We will go into these in the very next chapter.

The project managers took the most practical approach possible, building on the existing de facto process (known as the waterfall method and also discussed in the next chapter) to address the concerns of the auditors and the finance department. It bears remembering that many corporate IT departments were still reporting to the CFO at this time. Project management also has a chapter to itself, Chapter Eight.

IT managers reacted defensively. The Chaos Report‘s first paragraph referred to a paper co-authored by the computer scientist Alfred Spector[5].

“In 1986, Alfred Spector, president of Transarc Corporation, co-authored a paper comparing bridge building to software development. The premise: Bridges are normally built on-time, on- budget, and do not fall down.

….

One of the biggest reasons bridges come in on-time, on-budget and do not fall down is because of the extreme detail of design. The design is frozen and the contractor has little flexibility in changing the specifications. “

IT managers did not have to be told twice, and the quest to nail down specifications became an absolute mania. To my dismay, IT managers rushed to become “the department of No”, often taking a truculently defiant stance that no estimates would be issued, no commitments made, until the internal business client signed in blood that the requirements were set in stone and complete.

I saw this as a fast track to marginalization and insignificance because as the Chaos Report also pointed out on the same page:

“…in today’s fast moving business environment, a frozen design does not accommodate changes in the business practice”.

Commercial Off the Shelf

I was not wrong. The nineties became a time of unprecedented friction between IT and the business units within companies, and this brings us to the response of the business managers and auditors.

Just as freezing requirements became an obsession for IT managers, bypassing IT completely became a fixation for many business managers. With the success of the PC and shrink-wrapped software they figured they had the tools to do it. COTS became the buzzword of the day. It is an acronym for Commercial Off The Shelf, and the idea was that eliminating internal development projects would eliminate project failures. Let a third party assume the risk went the thinking. If they fail to deliver, then we don’t pay them. The company is protected. This philosophy was very closely aligned to the overall business trend towards outsourcing and suited the purchasing department and the auditors just fine, thank you very much. No less a personage than Fred Brooks endorsed the idea. For a number of years at the end of the nineties and the early years of the millennium, the policy of purchasing COTS instead of opting for internal program development was anointed best practice and pursued aggressively.

This trend hit its peak during the time I was CTO of a large international organization. Every other week, I was meeting with an external software vendor who had been brought in by a business manager in an attempt to do an end run around IT only to be brought up short when they discovered a need to integrate with in-house systems.

Unlike many other IT managers, I was not hostile to these vendors. I tried to be tough but fair. I was fundamentally sympathetic to the business users’ desire to cut me out. I was the representative of a department that seemed to take a perverse delight in thwarting even the slightest progress, patiently lecturing in the most condescending of tones that business needed “to understand” this, that or the other thing, or “that’s just not the way it works,” or just like the building contractor tells you about your kitchen renovations, “you can have it fast, good, or cheap, but not all three”.

James H. Boren’s delightful adage from his legendary work When in Doubt, Mumble is:

“Bureaucracy is the epoxy that greases the wheels of progress,”[6]

I used to joke that I was an international bureaucrat, and it was my job to prevent things from happening. But in reality, I deplored the attempts of my colleagues to make business conform to the limits that IT lacked the courage to surpass. I felt, as I always have and still do, that technology has no relevance if it is not used in service of some human pursuit such as the pursuit of business. I wanted my department to push whatever technology or process boundaries it needed to in order to keep up with the demands of the market and the need of the business to stay competitive.

I successfully pushed for a reorganization that moved IT Business Solutions into a separate team from that of the glass house so we could be free of their foot-dragging and no-but-isms. I deliberately had the IT Business Solutions team act just as a third-party software vendor would. I bid competitively against the external vendors the business managers brought in. I tried to win on merit, not hegemony. I placed my IT Business Solution Managers in the departments they served and drilled them to never respond to an idea with the type of passive-aggressive statements that the other IT managers insisted their team members use. Phrases such as “It might be very difficult…” and “it could be very complicated” and the infamous “you have to understand…” were replaced by “that sounds like a good idea, let’s see what it would take to make that work” or “I think I understand why you want to go in that direction. Can I just play it back to you to make sure I do?”

But my efforts notwithstanding, the best practices of the purchasing department and auditors saw to it that for several years the COTS vendors did very well, selling systems to business managers who signed contracts in blissful ignorance of the fate that awaited them.

The ultimate outcome of the COTS fad was tragically predictable because large public companies all have two things in common.

First, all of them have entirely unique, byzantine processes that are sacred and totally unchangeable because of corporate culture. Large companies have strange ways of doing things. One large company I worked at (a multibillion-dollar corporation) took Gross Revenues, deducted only commissions (not any of the other costs) and called it Net Revenue – not exactly what the rest of the world understands by that term. My favorite was the organization that created Northern Asia and Southern Asia as two territories and then declared Singapore to be in Northern Asia. So mighty were we, that even the earth’s geography would bend to our will. These are just a few small examples of the separate reality that large corporations live in.

Second, they all evaluate expenditures as being driven by one of only two possible motivations: They make investments either to get ahead of the competition, or so as not to get left behind by the industry.

When an innovation occurs (technical or any other kind), a few adventurous, risk-tolerant executives will seize on it to get ahead of the competition. Therefore, they want to build in-house to keep things proprietary. This is a relatively cost-insensitive endeavor. As long as the cost is a reasonable percentage of the revenues it generates, no further attention is paid. Growth is more important than cost control.

When enough other companies have copied the innovation, it is no longer a competitive advantage and the adventurous executives completely lose interest in it. Companies that join the trend late benefit from low prices because third-party vendors will have entered the market making it a commodity. The conservative, risk averse executives that inherit responsibility for the early in-house innovations feel pressure to abandon expensive proprietary implementa­tions in order to bring their costs down to the same level as that enjoyed by the late comers. They will then seek a cookie cutter solution (ideally maintained by a third party) at the lowest possible cost. All innovations suffer this fate; the line is constantly being redrawn. Today’s precious proprietary technology is tomorrow’s boat anchor. Like some sharks, companies have to keep moving or they will suffocate.

The COTS strategy is suitable for these late-stage situations where a technology is no longer a competitive advantage. Everyone is happy with a cookie cutter solution as long as it keeps costs to a bare minimum.

However, for dealing with unique corporate culture and processes, or the desire for proprietary competitive features, COTS is an utter failure. The whole premise of COTS and the basis of its success is that it is cookie cutter. Trying to customize it is a recipe for disaster, and it is a recipe that serves generous portions. Disasters with COTS customization projects became legendary, even more prone to spectacular failure than internal custom development.

COTS fell out of vogue on the heels of a string of highly publicized multi-million dollar failures such as the 1993 shipping and inventory catastrophes that brought drug company FoxMeyer and appliance maker Whirlpool to bankruptcy court with SAP, and the dire shortage of Hershey’s Kisses and Jolly Ranchers on the shelves for Halloween 1999 after Hershey tried to implement COTS software from SAP, Seibel, and Manugistics.

After a number of these debacles, there was simply no way that anyone could conceivably continue to call it best practice to buy COTS unless the intention was to use it exactly as-is. This coincided with some very significant changes to accounting rules, and between the two things, in-house custom development suddenly came very much back into fashion.

[1] Rothfeder, Jeffrey, It’s Late, Costly, Incompetent – But Try Firing a Computer System. Business Week, November 7, 1988.

[2] The Project Management Institute estimated that North American companies lost “nearly $300 billion on late, overbudget, or failed implementations during 1999–2001”

[3] Standish Group International. The Chaos Report; www.standishgroup.com/sample_ research/PDFpages/Chaos1994.pdf.

[4] KPMG. Report on IT Runaway Systems. [Online]. Strategys for KPMG Management Consulting, 1994. [16/02/2017]. Available from: eis.mdx.ac.uk/research/SFC/Reports/KPMG_ITsystems.pdf

[5] https://www.projectsmart.co.uk/white-papers/chaos-report.pdf

[6] Boren, James H. When In Doubt, Mumble. New York [Etc.], Van Nostrand Reinhold, 1972.

EXCERPT TWO

"Nothing new under the sun

As I stated at the start of the book: I propose the industrialization of IT and application development. Now, I expect that at least some of you are asking: if this is such a great idea, how come nobody has thought of it before?

The answer is of course, it has been thought of – and tried – many times before, by some very smart people. I have already written about some of those efforts, and I will introduce you to some new ones in this chapter.

I’ll start with this Wikipedia entry[1]:

“Ad hoc code reuse has been practiced from the earliest days of programming. Programmers have always reused sections of code, templates, functions, and procedures. Software reuse as a recognized area of study in software engineering, however, dates only from 1968 when Douglas McIlroy of Bell Laboratories proposed basing the software industry on reusable components.”

McIlroy made his proposal for “Mass Produced Software Components” at a conference sponsored by the NATO Science Committee held in Garmisch, Germany, the 7th to 11th October 1968.

He opened his paper with this:

“We undoubtedly produce software by backward techniques… Software production today appears in the scale of industrialization somewhere below the more backward construction industries. I think its proper place is considerably higher, and would like to investigate the prospects for mass-production techniques in software.”

He added:

“Of course mass production, in the sense of limitless replication of a prototype, is trivial for software. But certain ideas from industrial technique I claim are relevant…The idea of interchangeable parts corresponds roughly to our term ‘modularity,’ and is fitfully respected. The idea of machine tools has an analogue in assembly programs and compilers. Yet this fragile analogy is belied when we seek for analogues of other tangible symbols of mass production. There do not exist manufacturers of standard parts, much less catalogues of standard parts. One may not order parts to individual specifications of size, ruggedness, speed, capacity, precision or character set.”

McIlroy was well ahead of his time. His paper did not trigger immediate industry action, so he went on to quietly lead the Unix team, and to create Unix pipes, the part of Unix that makes it possible to connect small programs together. As I explained in Chapter Two there is an underlying philosophy to Unix: “the idea that the power of a system comes more from the relationships among programs than from the programs themselves”. Pipes are one of the key mechanisms to do this. In the words of Dennis Ritchie:

“One of the most widely admired contributions of Unix to the culture of operating systems and command languages is the pipe…”[2]

Unix pipes are at the heart of McIlroy’s philosophy[3]:

1. Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new “features”.

2. Expect the output of every program to become the input to another, as yet unknown, program. Don’t clutter output with extraneous information. Avoid stringently columnar or binary input formats. Don’t insist on interactive input.

3. Design and build software, even operating systems, to be tried early, ideally within weeks. Don’t hesitate to throw away the clumsy parts and rebuild them.

4. Use tools in preference to unskilled help to lighten a programming task, even if you have to detour to build the tools and expect to throw some of them out after you’ve finished using them.

Note the last item: he is talking about transfer of skill to machinery (or code in this case).

Unix was the first implementation of McIlroy’s vision. Arguably, the next one was Brad Cox’s interchangeable software components (software ICs) in Objective-C, a little bit more than a decade later (the usual time required for adoption of new technology it seems). They most certainly did transfer skill; the NextStep libraries transferred a considerable amount of programming skill to a package that could be easily re-used by a programmer with considerably less skill (like me). However, they only worked in Objective-C, and not everybody wanted to use Objective-C. More importantly, it still required some skill to use software ICs. NextStep was not yet to the point where semi-skilled or unskilled labor could use it to assemble a program without help.

Next, in the early 1990’s the OMG proposed the CORBA (Common Object Request Broker Architecture) standard, and Microsoft introduced its OLE and COM (Object Linking and Embedding and Component Object Model) models.

CORBA promised to provide out-of-the-box multi-vendor interoperability. It may have been the first credible promise of Mass Produced Software Components because of the number of influential participants in the OMG. Yet despite significant investment by various vendors, it failed to establish a lasting presence for a variety of reasons, mostly centered around its bloated design-by-committee feature. It was just too much of too much. As a result, I would wager there are many more mission critical COBOL-based systems running today than there are CORBA-based ones.

Amusingly, at the time of this writing, the link to “Who is using CORBA already?” on the official OMG “CORBA® BASICS” page[5] leads to absolutely nothing. (Bonus points for the old school insistence on using the registered trademark symbol. AT&T would be proud.)

As for Microsoft’s Visual Basic component architecture, its language independent suc­ces­sor OLE/DCOM and its spiritual successor .NET, they were resisted by large swaths of the market because they were Microsoft “standards” that in practical terms only worked on Windows, In a world that was rapidly adopting the web as its preferred platform for applications, solutions that did not work on Unix (and later on Linux) servers were not going to succeed. In fact, just as with Objective-C, any solution that depended upon just one operating system, or one language would never succeed across the board.

And I feel that I can very safely predict: the IT industry will never agree to pick just one language or operating system for everyone and everything.

Concurrently with McIlroy, Daniel Teichroew, Professor of Industrial and Operations Engineering at the University of Michigan, had started on what he called the Information System Design and Optimization System project in 1968. Although very interested in programming and automation, he was a statistician and Management Information theorist, not a programmer. His approach was markedly different than McIlroy’s.

A well-known and oft used cliché in IT is: “you got what you asked for, not what you needed.”

Teichroew’s starting point was “the problem” not the code that solved the problem, and he intended to ensure that what one “asked for”, was indeed what one “needed”.

To remove ambiguity in stating problems (now usually called “requirements”), he developed the Problem Statement Language, the idea being that a formal way of describing require­ments would allow for the reliable automated production of code by a Problem Statement Analyzer, a kind of compiler if you will. A traditional compiler converts a 3GL like C or PASCAL to machine language (or sometimes an intermediary language). The Problem Statement Analyzer would convert the Problem Statement Language into a conventional programming language such as C.

Parts of his work, specifically the focus on problem analysis as a means of ensuring successful development, would be picked up by the object-oriented analysis and design researchers. It lives on in the “use case”, which is a direct outgrowth of Problem Statement Language. Other parts of his work became the foundation of CASE, which stands for Computer Aided Software Engineering. The idea (which was a good one) was to apply to software the same principles that were successfully used in CAD/CAM (computer-aided design and computer-aided manufacturing).

CASE tools became popular and were widely used for development of mainframe and minicomputer applications in the 1980s and early 1990s. With the decline of the mainframe, the CASE banner was taken up by the Object Management Group as part of the standardiza­tion of UML (see Chapter Six) and was embedded into a number of tools such as Rational Rose (it later went through a number of name changes) and Silverrun, both of which still exist.

In 2001 the OMG took another run at promoting these concepts, this time under the banner of Model Driven Architecture (MDA). Under MDA, a platform independent model (PIM) was created first to then be machine translated to a platform specific model (PSM). This was undoubtedly the right idea, but it went nowhere.

To a carpenter with a hammer, the world is a nail.

You may wonder, if the previous solutions were such great ideas, then why did they never really succeed? Why is the problem of IT Project failures still as present as it ever was?

Because to a carpenter with a hammer, the whole world looks like a nail.

NextStep, COM, .NET, CORBA, CASE, MDA; all had a fatal flaw stemming from a bias shared by almost all programmers, computer scientists and software engineers: to them, writing code is the alpha and the omega. The beginning and the end. It is all that there is.

All of the above attempts at software industrialization focused on the “creative” part of development: writing code that “solves a problem” as expressed in a requirement or use case.

I expect that you are now asking yourself: “How could that be a flaw?” Isn’t that what programmers do? The answer is no, that is not what they spend most of their time doing. It will probably shock you to learn that enterprise developers are unlikely to spend more than 10% of their time actually writing new code, creating new functions, being creative.

Only the developers working for a FANG, (Facebook, Amazon, Netflix, and Google, remember?) writing compilers, creating advanced image, or language processing, or researching, are spending a lot of time writing algorithms.

Alexander Stepanov, the primary designer and implementer of the C++ Standard Template Library, relays to us[6] that Scott Byer, the architect of Adobe Photoshop, estimates that 90% of developer efforts are dedicated to “glue” and housekeeping tasks such as memory management, scripting, UI management, file I/O, and color management. 10% is spent on “substance”.

Stepanov presents the following estimates of how much time is spent on what he deems “substance” for a variety of application types:

· Word processing – 3%,

· Presentation App – 1%,

· Databases – 10%,

· Technical/CAD – 30%,

· Operating System – 1%, and

· Enterprise Application Software – 1%.

From personal experience, these numbers sound just about right to me.

[1] https://en.wikipedia.org/wiki/Code_reuse

[2] “The Evolution Of The Unix Time-Sharing System.” AT&T Bell Laboratories Technical Journal, vol 63, no. 6 part 2, 1984, pp. 1577-93. – https://www.bell-labs.com/usr/dmr/www/hist.html

[3] Doug McIlroy, E. N. Pinson, B. A. Tague (8 July 1978). “Unix Time-Sharing System: Foreword” (PDF). The Bell System Technical Journal. Bell Laboratories. pp. 1902–1903. McIlroy was head of the Bell Labs Computing Sciences Research Center while Unix was being written.

[4] An example of “agile” philosophy long before the term became popular. Other examples abound, most notably the admonitions of C.A. Hoare in his address The Emperor’s Old Clothes, (Hoare, Charles Antony Richard. “The Emperor’s Old Clothes.” Communications Of The ACM, vol 24, no. 2, 1981, pp. 75-83.)

[5] http://www.omg.org/gettingstarted/corbafaq.htm I am not sure why, but the page is available in two languages, English and Belorussian.

[6] Alexander Stepanov: Industrializing Software Development. A keynote address at The First International Conference on Embedded Software and System, Zhejiang University, Hangzhou, P. R. China, December 9, 2004.