Whenever a disaster occurs, the human instinct is to cover it up. That usually is not possible in civil engineering where a building collapse produces a pile of debris.
When a software project fails, the only visible evidence is an accounting ledger that is much easier to conceal. When a software project fails, all involved, from the executives who cooked up the idea to the consulting companies that built it, try to cover up the disaster. Because of this ability to conceal, there has not been strong effort to prevent software disasters from occurring.
We can distill all these software engineering failures into a simple business problem: Software costs too much.
If you wanted to address that cost problem in a scientific way you would:
- Use development tools that maximize productivity;
- Set up physical work environments to maximize productivity;
- Ensure developers have the right equipment to do their jobs most efficiently;
- Put in place personnel policies to reward and retain the most productive developers; and
- Put in place software management policies to ensure systems are properly designed and to prevent scope creep.
That kind of change requires knowledge of the software development process. These are issues that your average accountant has no conceptual understanding of.
But accountants make high-level decisions in corporations.
When you put the software cost problem in the hand of accountants, they understand it as: American computer programmer cost $90 an hour and Indian computer programmers cost $80 an hour.
The obvious flaw in that accountant analysis is that in the best case it simply makes disasters cost less.
I shared with Stefan an experience I had before law school. I joined a project written in C++ that had serious performance problems. The original developers were not familiar with table joins in database queries. They wrote the system so that it used millions of nested queries where one query would suffice. I was in the process of replacing these millions of queries with single queries that obviously boosted performance tremendously.
While working on this issue, a senior accountant-type in the company (without consulting anyone familiar with the structure of the system) hired an Indian body shop to rewrite the entire system in Java to solve this problem. Their legion of H-1B programmers slavishly copied the C++ code into Java, including the parts that used millions of queries where one would suffice. The result was even slower than the original — another software disaster.
It is this fundamental problem of software cost that is driving the demand for H-1B workers. Unfortunately, cheap labor on H-1B became a distraction from fixing the underlying problems in software engineering. The H-1B opiate has thwarted the advancement of software engineering and undermines American leadership in this area.