What’s wrong with complexity?

We tend to design things that are complex, and that can be our undoing.

 

Technologists love intricate mechanisms.  That’s why many of us, as kids, took things apart, and some of us even put them back together again.

In my training as an engineer, I enjoyed learning how mechanical, electrical and chemical things worked.  And the more elaborate the mechanisms, the better the challenge and the satisfaction of getting the understanding.

We tend also to design things that are complex, particularly if we’re in software design, because software is layered into abstractions almost without limit.  Database systems linked via networks to computational engines and on to user-interaction devices are full of opportunities to exercise our power of design in the face of complex interactions.

Yet complexity can also be our undoing.  Consider this from Andre Zolli’s article about the crash of Air France Flight 447:

It was complexity, as much as any factor, which doomed Flight 447. Prior to the crash, the plane had flown through a series of storms, causing a buildup of ice that disabled several of its airspeed sensors — a moderate, but not catastrophic failure. As a safety precaution, the autopilot automatically disengaged, returning control to the human pilots, while flashing them a cryptic “invalid data” alert that revealed little about the underlying problem.
 
Confronting this ambiguity, the pilots appear to have reverted to rote training procedures that likely made the situation worse: they banked into a climb designed to avoid further danger, which also slowed the plane’s airspeed and sent it into a stall.
 
Confusingly, at the height of the danger, a blaring alarm in the cockpit indicating the stall went silent — suggesting exactly the opposite of what was actually happening. The plane’s cockpit voice recorder captured the pilots’ last, bewildered exchange:
 
     (Pilot 1) Damn it, we’re going to crash… This can’t be happening! 

 
     (Pilot 2) But what’s happening?
 
Less than two seconds later, they were dead.  …
 
We rightfully add safety systems to things like planes and oil rigs, and hedge the bets of major banks, in an effort to encourage them to run safely yet ever-more efficiently. Each of these safety features, however, also increases the complexity of the whole. Add enough of them, and soon these otherwise beneficial features become potential sources of risk themselves, as the number of possible interactions — both anticipated and unanticipated — between various components becomes incomprehensibly large.          [Want to Build Resilience? Kill the Complexity by Andrew Zolli, 9/26/2012]
 

This is certainly a cautionary tale about messages that don’t convey important meaning.  But it’s also a warning about interactions that were designed but couldn’t be tested or evaluated in all their combinations.  That’s what complexity leads to.

Disasters like Flight 447 nearly always require a complex system interacting with a human.  Remember the key learnings of the Apollo disaster: NASA’s safety analyses were not being followed up because of a dual-agenda management system.  The bottom line was that they relied on the fact that heat-shield tiles had never yet caused serious damage.

When you’re responsible for a project that is complex, you need to address that complexity in two ways.

First, you need to be sure that the people doing the analytical and design work know what the possible failure mechanisms are, how to compensate for them without adding a lot more complexity, and have scheduled adequate tests to validate the robustness of the design.

Second – and this is the more difficult – you have to be sure that the people implementing the project and the people managing the project (including yourself) are not harboring private agendas that may undermine the effectiveness of the analysis and design and testing.  Adding ship-date pressure on a team, for example, can cause them to short-change the test plan and declare a product ready to ship when it still has serious faults.

The second area is where your experience with people doing projects will help you most.  Listening a lot to project team members and following up on hints of conflict over goals or processes will help you stay current on the health of your project.

Finally, you can become an advocate for simplicity.  When faced with a choice in a project between a more complex solution and a simpler solution, go for the simpler one.  Often this will allow you to discover sooner whether or not the solution is adequate.

Some projects, of course, become excessively complex no matter what you do.  This may be a time when the most responsible thing you can do is recommend that the project be cancelled.  Better to have no product than one that kills.

No silver bullet

Software is in everything and we and our businesses depend on it more and more.  Yet Software Quality is not rising, so we have rising numbers of failure incidents and out-of-control costs in maintaining software.  What should you do about it?

Software, software, software

No matter where you look, there is software.  Whether you inspect the thermostat in your home, look at the smartphone in your pocket, or lift the hood of your car, you find digital chips running software that keeps the device going.

And this doesn’t even begin to describe all the software that is running in your computer and in The Cloud.  Software is everywhere and we are dependent on it for so many things in our daily lives.

If you have something to do with creating software, you’re probably in a secure job because software creation is not going away.  On the other hand, you’re probably worried about keeping up with the latest techniques and standards, because software development is in the public spotlight more and more.

Why?  Because software failures, system data breaches and rising maintenance costs are in the news more than ever.

Software can be stable and reliable

I attended this month’s meeting of an organization called SofTech and enjoyed hearing Fred Davis talk about the latest gadgets – which, of course, are full of software.  And in that room were some of the most experienced software developers in the San Francisco Bay Area.  Yet even among those high-tech gurus there is an unspoken acknowledgement that software quality is not very high overall, and that creating stable and reliable software is an arduous undertaking.

How can we make it less arduous?  Well, as Fred Brooks explained, there is no silver bullet — no single countermeasure that will make software development become predictable and reliable.  If you want reliable software, you have to organize and execute deliberately, monitor the results regularly and keep up with the evolving tools and methods that incrementally make the process better.

To learn more about development issues, have a look at Technical Debt.  Also visit SEI, PMI, and CISQ.  But above all, get expert guidance that is not focused solely on technology and tools, because creating reliable software depends as much on management and organization as it does on tools and process.

If you’re managing development projects …

I’ve started offering a series of webinars on managing development projects.  The first two were titled The 10 Danger Signs of a Failing IT Project and How to Fix a Failing IT Project.  The third one, in January, will be Why Agile Won’t Fix All Your Problems.

Even these webinars won’t fix all your problems.  But you may become aware of the possibilities and some of the pitfalls in development.  And that could be enough to get you on a path of improving the software quality in your enterprise.

 

Is your software stable or static?

In most professions, it’s good to have stability in the things you work with.  With software, stability is good, but often we confuse static with stable.  They are not the same.

Static software decays and becomes useless.

In a previous article, Why does it cost so much to maintain systems? I explained how software updates are critical to keep it alive:

Software by its nature is constantly evolving.  Not only do users ask for new and modified features, but the systems on which the software runs keep changing, so the software has to be modified to fit new environments.  These factors guarantee that updates have to be released several times a year to keep things current.

Here are some indicators that software is stable:

• Updates are regular but not urgent

• The list of bug fixes in each release is not excessively long

• You don’t experience crashes & freezes on the system

• The software “plays well with others” – there are no negative interactions with other software packages

• It scales up smoothly – there are no abrupt limits as the data size or workload increases, only a gradual slowing of response time

• The vendor’s support is consistently accessible and useful

On the other hand, static software is an entirely different thing.  If software is static it means that there are no updates, changes or evolutionary steps being taken to keep the software current.  As a result, some or all of the following will happen:

• The software will not run in new environments, such as latest release of the operating system

• The files being used with the software do not evolve with changing data formats, file systems and storage media.  Compatibility is lost with other software that begin using new data and file formats.  Old backup copies of data may not be readable on new storage devices.

• The software will not communicate using new network interfaces.  When it does communicate, it may be using old protocols that slow down the speed of transfers and do not use new features available in the network.

• The software may not be able to interact with cloud-based applications and databases that have been added since the software was released.

Stable software requires constant attention by the people who are maintaining it.  They should be in regular dialogue with the users of the software, have a list of issues they are investigating and correcting, and be using a set of maintenance tools that allow consistent and stable releases.

Strive to have stable, but not static software. 

Complexity is good – or is it bad?

I grew up in a family of engineers.  My father studied electrical engineering in college, but never practiced it because he graduated from college during the Great Depression.  Two of my uncles are engineers, and my older brother preceded me in going to Cornell as an engineering student.

I have always felt that engineering is not only an honorable profession, it also leads to a practical lifestyle that values inquiry, problem-solving and efficient solutions to the challenges in life.  So you may not be surprised to learn that I am a fully qualified lifelong nerd.  I love examining things to discover how they work.  And the more complex the mechanisms, the more interesting they are.

This is where it gets to be a problem.  When I invent something new, like a part of a computer, I revel in the complexity of the thing I’m building.  As long as the complexity serves a purpose, such as actually making the thing do what it’s supposed to do, my brain is tweaked in pleasurable ways when I contemplate the complexity.

If you’ve been reading any of the recent pieces about Steve Jobs, you’ll have understood that part of his brilliance was being able to conceive of simple and easy-to-use products that “just work.”  I worked with Steve in the early days of Apple, and I can verify that it was a challenge being an engineer in a place where the visionary boss kept revising the product based on his latest concept of simple.  Yet even engineers have a principle they repeat to each other to counterbalance their tendency towards complexity – the KISS principle: “Keep it simple, stupid”.

A quote attributed to Einstein says “Make it as simple as possible, but no simpler.”  This teaching admonishes us to simplify our theories, but not so far that they no longer apply to the real world.  Jobs’ vision was to make products that contained complex technology but worked well and intuitively for the common person.  And from that basis, he led the creation of products that have changed the way the world works.

So does this mean that I’m giving up on complex ideas and mechanisms?  Not at all.  The mental contortions I need to undertake to understand complicated things still give me pleasure.  And I believe they keep my mind alive in important ways.  The key to living with such an engineering mind is to keep it from running my life.  I still listen to J.S. Bach’s music with satisfaction at the complexity of the counterpoint and harmonies.  But I also meditate on emptiness to keep the logical brain in check.

The next time you hold a complicated piece of consumer electronics in your hand – such as your mobile phone – take a moment to reflect on its complexity and its simplicity.  Encapsulating one of these in the other is an art.  And to accomplish that encapsulation, you need both engineers and artists.  Long may the engineers and artists work together.

John Levy works with Finance and Operations executives who are sponsors for new IT-based business capabilities.  He helps them to succeed with their projects and to transform their relationship with IT.

Getting business value from every dollar spent in IT is not easy.  You need a guide who is knowledgeable about technology and also speaks the language of business.  John specializes in rapidly getting IT to align with business strategy and to contribute efficiently to the success of the enterprise.

John has been consulting in industry for over 20 years.  His book on management for technology executives, Get Out of the Way, was published in May 2010. 

For more information, please visit https://johnlevyconsulting.com , email him at info@johnlevyconsulting.com , or call 415 663-1818.

 

Business, Academia, Government – do we have the same problems?

Every one of us is dealing in one way or another with high technology. Whether it is by trying to develop a product, trying to deliver a service, or just preparing our slides for a presentation, we all deal with the high-tech world.  This usually means that we must communicate with high-tech people, and typically the results we get are dependent to some extent on how well the high-tech people do their work.

Communicating with high-tech people is a challenge. Not only do they speak their own brand of jargon, they also tend to be very literal.  Like the literalness of the computer itself, high-tech people seem to think that if you ask for a three-pronged left-handed widget (or a thingumbob, if you like), then if they deliver a three-pronged left-handed widget to you, you should be happy.

Unfortunately, it doesn’t work that way. With software, for example, the requirements are never completely known.  Typically, when the first working model of a new software system is shown to the people who asked for it, their reaction is: “Oh.  I see what you have here, but what I really want is something different.”

This can be frustrating for the technologists who worked for a long time on the development.  One of their countermeasures now is using Agile development practices, in which a working prototype is shown to the “customer” early and often.  This allows the developers to correct their course early and gain confidence that they are building something that will actually be useful.

But why is it so hard to specify what we want in advance? Is it because we don’t speak the same language as the techies?  Or is there something inherent in high-tech that obscures the simple outcomes that we know we want and we think we have asked for?

I believe it is both. Not knowing how high-tech stuff is constructed, we don’t know which jobs are hard to do and which are easy.  We also don’t know how elaborate the underlying structure has to be in order to get what looks like a simple result.  So we ask for things that we want and find ourselves puzzled by the groans from the technologists who see years of work ahead of them to satisfy the request.

We also don’t really know what we want when it comes to interactions with a computer-based system, because the possibilities are endless and the examples we’ve seen in the past color our view of what we think the interactions should be.  For example, if you’ve used Word Perfect for years to do your word processing work, you will not find it easy to switch to Microsoft Word, because the interactions and functions are different.

There’s a new discipline in computer systems development called user interaction (UX) design.  It calls on specialized skills ranging from graphical design, human perception and interaction protocol design, to database design and web programming.  But even as this new discipline is helping to make systems easier to interact with, no one can substitute for you, the user or customer, in defining what the system should do.

Sometimes you have to say, “I want it to be easier to use than this,” when you see how a system works, even when you don’t know how to make it easier.  If you challenge the development team to try different ways to make it easier, you will usually get something better.

But this poses a problem. If they are experimenting with various ways to make the system easier to use, how long will it take to get to the finish line?  How much will it cost?  The fact is that doing engineering and design requires creativity and experimentation.  And you can’t schedule a breakthrough.

So you have to settle for setting a limit on how long or how costly the project is to be.  An entrepreneur may run out of money before delivering a satisfactory system. But if you are constrained to actually get a working system, you want the best you can get within the constraints.

This comes back to the Agile approach. If you ask to be shown a working prototype often, you can do course-corrections frequently while you also gain confidence that the developers are meeting the most important criteria for your project, because you make them show you how the system meets those criteria first.

The Agile Management Bottom Line

Give up trying to specify everything at the start.  Begin by prioritizing the key features or results you need, and ask for frequent demonstrations of a working system.  You’ll end up with a lot more confidence in your high-tech developers, and they will be less frustrated with you.

—–

John Levy helps business managers who are frustrated by the lack of results they are getting from IT or Engineering.  He specializes in rapidly getting high-tech teams to align with business strategy and to contribute to business success of the enterprise.

John has been consulting for managers in industry for over 20 years.  John’s book on management for technology executives, Get Out of the Way, was published in May 2010.

For more information, please visit his website at https://johnlevyconsulting.com ,

Email him at info@johnlevyconsulting.com , or call 415 663-1818.

What’s the matter with IT?

Information Technology (IT) is a name that covers all the stuff (computers, networks, software) that makes businesses work.  As a key part of every business, IT has become a loved and hated department.  Loved because the capabilities of IT keep things humming in business.  Hated because there is something about IT that keeps it apart from the rest of the business.

Businesses keep IT separate for a number of good reasons.  IT needs technical specialists, and these specialists have to interact with each other.  IT has to maintain the systems and networks that keep things running, and these systems are often far from the home office.  Finally, managing IT people requires some kind of management specialists who know what makes technologists tick.

There are also some bad reasons for separating IT from the rest of the organization.  One is to keep business people at the operating level from having too much influence on what IT does.  After all, if you let a low level business manager ask for everything he or she wants from IT, IT might not have enough time to do the big projects planned by the top executives.  Another is the belief that IT doesn’t speak the language of business.

One of my client companies used to have the head of IT (the CIO) report to the head of Finance (the CFO).  This guaranteed that the CIO had a financial perspective on everything.  While that is the right perspective for a department that belongs under Operations (people who keep the buildings and the commuter buses running), it is not the best perspective for and IT department that is trying to contribute to the business bottom line by developing innovative software packages and better products.

This company had a large call center (people who answer the phone when you call for support) located 750 miles from the home office.  The whole IT operation, except for their offshore contractors, was located in the same building as the call center.  Upstairs from the call center were the software developers and managers who were implementing the latest web site upgrades and support software for their sales agents.

Software development is not Operations, it is Engineering.  If you treat software engineers the same way you treat call center operators, you discourage them, because they need a different working environment and a different set of criteria for their success.  Discouraged software engineers leave to find a better place to work.  The most experienced and most productive ones of them leave first.

IT needs to be integrated with the organization.  Not only does the management of IT have to be aware of and fully behind the strategic initiatives of the company, they should be actively proposing and executing projects that increase the competitiveness of the company.  The more that IT can sit side-by-side with their business-oriented peers in the company, the better the strategies and the results will be.

The Agile Management Bottom Line

Get IT out of its silo and into the main stream of your business.  If you don’t understand what IT does, start asking questions.  But don’t banish IT to the boondocks just because they’ve got a lot of funny-looking machinery in the closet.  You need them and they need you.  Start talking.

John Levy helps business managers who are frustrated because they are not getting what they need from their IT or Engineering organizations.  He helps them get predictable, consistent and innovative results from high-tech people in IT and product development.

John’s clients include companies in insurance and manufacturing, as well as software, computers and storage.

John’s book on management for technology executives, “Get Out of the Way,” was published in May, 2010.  His website is https://johnlevyconsulting.com and he can be reached at 415 663-1818 or info@johnlevyconsulting.com