Where Has the Application Development World Gone Wrong?

I am frustrated with the evolution of software development over the last 20 years.  When I started in the industry, I played around with Paradox as a development environment.  Then Oracle released Forms 4.0 and Reports 2.0.  These were first generation GUI tools that were so bad that it took Oracle nearly 10 years to recover from the loss of reputation that these tools engendered.

The next release of the tools (Forms 4.5 and Reports 2.5) were actually pretty good (even the current version of Forms and Reports are not so far from that early release) and I got into real database application development.

Peter Koletzke and I built a wonderful template library that included hundreds of UI and code objects to make the products even more efficient. Dulcian developers built very complex applications very quickly. We used Oracle Designer to generate our database, and life was pretty good.

As an industry, we figured out how to build good applications quite well.  There were a few different camps (100% application generation from Designer, 100% manual build, and generate then break the link) but we had consensus around a few ideas and each of these groups got pretty good at building systems.

Then Java came along.  We all had to move to this new “thing.”  Oracle started out with UIX and BC4J (which ultimately evolved into ADF).  From the start, this was not such an easy new world. Even though I was enthusiastic about the new technology, I was disturbed by the following:

1. Screens that took me a day to build in Forms took me a week to build in ADF.
2. I could not make my applications do the same things that I could make them do in Forms.
3. The applications required LOTS more code and moving parts in them to do the same work that the old ones did.
4. Making changes was a LOT harder.
5. Even after I thought I had a working application, if I had not done everything right, it would fail when put into production.

As Java EE and ADF evolved, things got more and more complex.  ADF now has more parts than an Italian sports car.  In any big Java EE application, the architectural diagram has so many components that there is little wonder why these systems projects fail so often.

The only thing we seem to be getting better at is redefining failure.  Projects that used to take a handful of developers a few months now take an army of developers years to produce (at 10 times the cost).  If we budget a project at $3,000,000 and do it for $5,000,000 we are successful.  Of course, 15 years ago we would have built the whole things for $2,000,000 in a year).

We have moved from relatively simple tools with rich functionality to tools that are only marginally more capable, but are horribly more complex.  I really don’t understand it.  We are building (more or less) the same stuff that we built 20 years ago, but now it takes 10 times as long, costs 10 times as much, and fails more often than it used to. 

Why do we put up with this?