Why is the Bar Set so Low for Enterprise Applications?
It occurs to me that much of "Big IT" creates a well-oiled
organization that makes broken software seem acceptable. The breakage is
wrapped in layers of finely-tuned process.
Consider a typical Enterprise Application. There's a help desk, ticket tracking, a user support organization that does "ad-hoc" processing, and a development organization to handle bug fixes and enhancement requests. All those people doing all that work.
Why?
If people need all that support, then the application is -- from a simplistic view -- broken.
The organization, however, has coped with the broken application by wrapping it in layers of people, process, tools, technology, management and funding. The end users have a problem, they call the help desk, and the machine kicks in to resolve their problem.
It is a given -- a going-in assumption -- a normal, standard expectation that any enterprise software is so broken that a huge organization will be essential for pressing forward. It is expected that good software cannot be built.
We're asked to help a client create a sophisticated plan for the New Enterprise App support organization. Planning this organization feels like planning for various kinds of known, predicted, expected failures. Failure is the expectation. Broken is the standard operating mode.
Consider a typical non-Enterprise Application. Let's say, the GNU C compiler. Or Python. Or Linux. An almost entirely volunteer organization, no help desk, no trouble tickets, no elaborate support organization plan. Yet. These products actually work flawlessly. They're not wrapped in a giant organization.
Why is the bar for acceptability so low for "Enterprise" applications? Why is this tolerated?
Published at DZone with permission of Steven Lott, author and DZone MVB. (source)Consider a typical Enterprise Application. There's a help desk, ticket tracking, a user support organization that does "ad-hoc" processing, and a development organization to handle bug fixes and enhancement requests. All those people doing all that work.
Why?
If people need all that support, then the application is -- from a simplistic view -- broken.
The organization, however, has coped with the broken application by wrapping it in layers of people, process, tools, technology, management and funding. The end users have a problem, they call the help desk, and the machine kicks in to resolve their problem.
It is a given -- a going-in assumption -- a normal, standard expectation that any enterprise software is so broken that a huge organization will be essential for pressing forward. It is expected that good software cannot be built.
We're asked to help a client create a sophisticated plan for the New Enterprise App support organization. Planning this organization feels like planning for various kinds of known, predicted, expected failures. Failure is the expectation. Broken is the standard operating mode.
Consider a typical non-Enterprise Application. Let's say, the GNU C compiler. Or Python. Or Linux. An almost entirely volunteer organization, no help desk, no trouble tickets, no elaborate support organization plan. Yet. These products actually work flawlessly. They're not wrapped in a giant organization.
Why is the bar for acceptability so low for "Enterprise" applications? Why is this tolerated?
(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)
Tags:






Comments
Daniel Kec replied on Wed, 2011/10/19 - 7:28am
Piotr Kochanski replied on Wed, 2011/10/19 - 9:35am
Either the author has never seen enterprise application or is simply advertising his employer, who is making money from showing Big IT how to build enterprise applications.
I like, however, how honestly http://www.thoughtworks-studios.com/ is bashing its own customers. It looks like that some Big IT (mentioned on the website), even after ThoughtWorks help, is still producing rubbish. What's worst, they are providing helpdesk for customers!! Such disgusting crime would never be commited in the agile open source World.
The point is that at some scale 'agile' development process simply does not work (think of integration with the number of third parties, think of necessity to take into account law regulations totally abstract to average developer, complicated bussines logic - medicine, insurance, banking, etc. that need bussiness analysts, I can go on for an hour like that).
A lot of enterprise applications are much, much more complicated then Linux kernel or Python interpreter. And they cannot fail - think of bank transactions.
Mind this old article How many Microsoft employees does it take to change a lightbulb? and the interesting comment by Raymond Chen:
Huge penetration of Linux on desktop suggests that maybe some kind of "enterprise application"-like process would be helpful.
And no, Linux kernel is not developed by "almost entirely volunteer organization", see http://martinezjavier.blogspot.com/2011/03/canonical-contributions-to-linux-kernel.html. All the 70+ % contributors are boring enterprises with their tickets, timesheets, managers, etc.
Michael Remijan replied on Wed, 2011/10/19 - 9:32am
Charles (Ted) Wise replied on Wed, 2011/10/19 - 3:13pm
Nicolas Bousquet replied on Wed, 2011/10/19 - 6:12pm
Rick J. Wagner replied on Wed, 2011/10/19 - 8:16pm
in response to:
Piotr Kochanski
Jan Kotek replied on Thu, 2011/10/20 - 3:15am
J Casey replied on Thu, 2011/10/20 - 4:25am
Steven- I think you have nominated the solution. When some 9-5 er submits a bug with their ERP package, reply with a zipped GNU C Compiler and say "Here you can solve that with this!"
seriously though, I agree with Charles. I think what you speak of can all be attributed to the ... not sure what to call it so I'll call it the "Reluctance to Re-write" problem. As soon as the "app" becomes a "product" it moves into the hands of people who know nothing about the to-do list or the need to re-write the x and y modules because they were done in a spectacular hurry just before the deadline. The guys now steering the underlying budget on which the product rides are only interested in more features on which to sell the thing. Rewriting the shonky original modules can have no net gain.
J Casey replied on Thu, 2011/10/20 - 4:26am
On further thought I think I just 'got' the essence of your article - what if we were to take all the money attributed to help desk and user support and sink it into making the product 100% bug free (i.e. so it works as per the user manual). Would we save money? That might get those guys steering the budget interested in the to-do list.
The help desk could be replaced with a recorded voice message "The product is fine. Is your network cable connected?, Is your keyboard working?, Do you have the latest OS service pack? ...."
Steven Goldsmith replied on Thu, 2011/10/20 - 10:07am
in response to:
J Casey
This segues me into my next point. Most "enterprise" software is of lower quality then the QSDA code you do in house. If you don't believe me just run SCA tools against the code base and see what you come up with (or maybe looks at the database design). I found the best enterprise products (this is "enterprise" insurance software) were only equal to in quality to in house code I would call marginal. Most vendor code was at levels that your continuous integration system would break the build. So in essence what I'm trying to say is that no matter how flashy or functional a system is it can be chock full-o-bugs. You have to integrate with systems and use development frameworks built upon every anti-pattern in the book. At the end of the day very few enterprise products (with the exception of basic servers such as DNS, EMail, Wiki, some databases) are of good quality and I don't see that changing any time soon.
Steven Goldsmith replied on Thu, 2011/10/20 - 10:06am
in response to:
Jan Kotek
Jianping Roth replied on Fri, 2011/10/21 - 1:53pm
Lund Wolfe replied on Sat, 2011/10/22 - 7:44pm
It is commonly held that better developers are hired by dedicated software companies to build commercial shrink wrapped software or volunteer to build quality open-source software (that becomes popular) than are hired for corporate IT. I've worked almost entirely in corporate IT, so I can't speak to that. There is a strong sense of "good enough", too. The users are a captive audience required to use the application and they acclimate to the fact that some stuff is broke or of poor quality/performance. As long as a problem isn't a show stopper and they can get their work done, they don't care, and features that enable them are far more important.
It may be cheaper to hire mediocre developers and surround them with a support infrastructure or it may not even be practical to expect to be able to find enough of the best developers willing to work in the corporate environment. It may be more practical to sustain a consistent level of quality, even if mediocre, by using a process and hiring (and cycling through) mediocre developers and support people with fairly specific roles than to depend on really good developers who may or may not be on the payroll and available at any given time.