This post originated from an RSS feed registered with Java Buzz by Weiqi Gao. Original Post: Why Do We Have Hype Cycles Feed Title: Weiqi Gao's Weblog Feed URL: http://www.weiqigao.com/blog/rss.xml Feed Description: Sharing My Experience... Latest Java Buzz Posts Latest Java Buzz Posts by Weiqi Gao Latest Posts From Weiqi Gao's Weblog

Ted Neward calls out DSL and functional programming as being the hypes du-jour:

Interoperability Happens: Domain-specific languages are the new phrase of the moment, and its emotional context is being built as we speak. Functional languages will be there sometime next year or the year after. For both, the euphoria is growing, and for each, in some period of n (three, maybe four) years will be crashing just as hard as they were built up, just as Ruby's and Visual Basic's and COM's and EJB's and WS-*'s and other technologies have done before it. It's as predictable as the flow of alcohol at an MVP Summit, or the consumption of either caffeine at an all-night code frenzy.

Ted also points out that similar things happen in the health field in the form of new diets, but electrical engineering and construction are less vulnerable.

I think I know why? Take a look at a typical house construction project: a team of less than ten people working for less than six months can build a house that will in general last, satisfactorily for the occupants, for a hundred years.

Now take a look at software projects: the last time I worked on a five people/six months project was, umm, never. Even the fifty people/five year projects that was delivered are not expected to last for more than five years before a new version will be needed.

The effort/reward ratio is too low. And we, or the stake owners of our projects, are always on the look out for the next new thing that will make our life easier.

However, our mind is build in such a way that we feel the pain of the tools that we are currently using a lot more than the benefits of the tools. For example, we statically typed language users tend to remember that one instance when we wanted to do something but the type system just won't allow us to do. But we generally don't even think about what the type system does for us day in and day out during the ECTD (edit-compile-test-debug) cycle, or constantly inside of our IDEs.

And sometimes we gravitate to the shiny new thing that will make our pain go away, be they a new language, a new framework, or a new methodology. But so far, every new thing that I've tried also brings with it a new set of pains in other areas.

But for too many times, we end up being disappointed. And we become bitter and cling to our C++ and static types.