In the early days of Java a strong argument used by the proponents of the technology was standards compliance. Later on the community realized that the standardized technologies were not enough to meet common project requirements or the way they worked was not the most elegant.
That’s why frameworks like Struts or Spring appeared. Nowadays standards seem to be a kind of unneccessary luxury.
But they are not! Java standards allow to avoid the vendor lock-in that people were always complaining about especially in terms of Microsoft technologies. But in the context of open source this seems to be forgotten. A lot of developers a willing to use every cool non standardized open source framework that appears never asking whether it’s standard compliant or not. Examples are Struts, Spring, Beehive, etc.
I think as long as no standardized technology is available which meets certain requirements it’s perfectly fine to use non standardized technology. At least if it has a sound background for instance by a large vendor or large independent developer community.
I know there are other factors like existing codebase which might influence a technology decision.
But if one has to choose between standardized and non standardized software the choice should be clear.
What is your choice?
EJB3 or Spring?
Classic J2EE or Beehive?
JSF or Struts?
2 thoughts on “Schizophrenic Attitude Amongst The Java Community”
I’m not sure I entirely agree. Choosing between standardized and non- standardized software depends on context. Hibernate is not
standardized, but JDO is. Does that mean I should choose JDO?
Clearly, Hibernate is often chosen – it is well supported, and accepted in industry. Likewise, should we use JSF (standardized) as opposed to Struts?
I’m not locked in if I use any of these non-standardized software.
Their source is usually open, and I can change frameworks at will.
For example, if you use Hibernate in Spring, then there are many abstractions available which makes it easy for me to swap to a
different persistence framework, say JDO. I think the key is to
realize when you are using "non-standard" software, realize it may not be supported at some stage in the future (if it’s not a de facto standard), and program accordingly, minimizing dependencies (easy with lots of interfaces and IoC). Blended is the way 😉
I agree with you when you say choosing the right software depends on context.
What I decribed was a attitude which I find somehow strange. I often discuss these things in projects. And the same people that always claimed that a software has to be standards compliant some years ago don’t seem to care about that anymore. A lot of developers are willing to work with every technology as long as it’s popular. But if you plan to build a mission critical application on top of such a software the question how long will this technology prevail is more important than the question how cool it is at the moment. In such a context I think it makes totally sense to choose JSF instead of Struts.
I my opinion there is a lock-in even in open source. If there isn’t a broad developer community behind a technology you will be dependent on this community. And fixing bugs or improving a framework on your own is not something that a company really wants to do, albeit they could do that because you they have the source code. It takes too much time and money.
From my experience changing frameworks at will without a lot of effort is very difficult. Maybe not for a persistence framework but definitely for a web application framework.
Most commercial applications that I know use in fact a blended approach with mostly commercial and standardized software for critical parts of the application and non-standardized software for logging, etc.
One exception is Struts which is widely accepted as a web application framework. But only because there was a lack of standardized alernatives for a long time. The JCP seems to be too slow to catch up with the demands of modern applications. It might be a good idea to invest more time in the establishment of powerful standards than in the next non-standardized open source framework. This would make the decision for the right framework a lot easier.