While installing MySQL for development purposes I remembered an announcement from Oracle in which they introduced Oracle Database 10g Express Edition (aka Oracle XE). According to the announcement and the Oracle website, XE is an entry-level database based on the code base of it’s big brother (or sister) that is free to develop, deploy, and distribute.
It is a great database for:
- Developers working on PHP, Java, .NET, and Open Source applications (it looks that I am the target audience
).. - …etc..
According to the Oracle website it should be easy to install and administer! While MySQL is a wonderfull database, easy to install and maintain, good tooling support etc, I still decided to take the plunge into the scary world called Oracle!
The download of 150 MB was ready and after 5 minutes I got my database up and running. Is this all I wondered! Yep indeed this was all. I switched a Java project to use the Oracle XE database and everything went smoothly from then onwards.
I must admit Oracle XE has it all in one download from database to administration. So am I going to use XE from now on 
? Could be! It sure has made a very good impression on me. So thumbs up for Oracle. They released a fine database but that is something I should have been expecting.
And by the way.. talking to Oracle guys is not so scary after all
I did a short investigation into the AppFuse project, to establish if this is a tool Consultants working for the LogicaCMG Java Competence Center can use in their projects.
What is AppFuse?
AppFuse is an application for “kickstarting” J2EE web application development. It consists of a set of libraries, jsp’s, templates and several build scripts. Running the ant new target in the AppFuse root directory will prompt for a few parameters of the target application, like database and package names. AppFuse then generates and copies a deployable web application that can serve as a starting point for further application development.
How well does AppFuse work in practice?
To find out how well AppFuse really works, I followed the QuickStart Guide, the Creating new DAOs and Objects in AppFuse, the Creating new Managers, the Creating Spring Controllers and JSPs and the Adding Validation and List Screen tutorials. I then tried to port the generated code to another RDBMS (Cloudscape 10.1). I also had a go at replacing the default two column page design with a three column design.
These are my findings.
Strengths
- Short startup time - I had a deployable, database driven, tested, 3-Tier J2EE application supporting authentication, authorization, logging, click through tracing etc. in less than 3 hours. Even taken into account that I already had a complete Java environment installed on my machine (JDK, Eclipse, MySQL, Ant), this is fast … very fast.
- Choose between IBatis and Hibernate - for persistence, AppFuse lets you chose between a DAO layer implemented using IBatis or Hibernate.
- Choose between Spring MVC, Tapestry, Webwork orJSF - for the Web Tier, you can chose between two Component based (Tapestry and JSF) or two Request based web frameworks (Spring MVC, Webwork).
- Support for Test Driven Development- apart from DAO, Manager and Web classes, AppFuse also generates Test Cases and the ant targets to run them, either individually or in logical groups (test-dao, test-web, etc.).
- Build script - the Ant build script consists of 1200 lines and 65 targets and covers everything from dropping, creating and populating the database to deploying to Tomcat and fixing CRLF for Unix Machines.
- Integration with Sitemesh - the JSP’s are build up using the the Sitemesh templating library, providing for clean separation between content and layout directives. Compared to for instance Tiles, Sitemesh is more powerfull and flexible.
- Released under the Apache License - it lets us freely use the software for company internal and commercial purposes and does not require us to submit changes that we make to the software back to the Apache Software Foundation.
- Documentation and community support - the tutorials and JavaDoc are quite good, and there is an active developer community using the software.
Weaknesses
- MySQL only - the generated code is targeted at the MySQL database system. AppFuse does not support other RDBMS out of the box - manual adaptations of the generated code are necessary to achieve this.
- No clean dependency management - AppFuse relies on ant build scripts and properties files to configure its (50+) dependencies. Usage of a tool like Ivy, a simple to use but powerfull dependency manager would be nice instead.
- Heavy reliance on XDoclet for code generation - this leads to code that belongs in the Integration Layer (i.e. Hibernate mapping definitions and column names) being part of the Domain Layer.
- Large build scripts - although they do provide a lot of functionality, the large build scripts are difficult to understand and maintain. It is also not always clear what the different targets do and how they depend on each other.
- Usage of Business Keys as PKs - in general, when using Hibernate, it is a best practice to use Surrogate Keys as PKs for database tables representing Business Objects (”User”, “Car” etc.). AppFuse ignores this and uses the Business Keys as PKs.
- Small committer base - it is unclear to me how large the developer base is that actively maintains and develops the AppFuse project. This is something to investigate when planning any long running projects.
Conclusion
AppFuse does what it promises to do, which is always nice: it kick starts a J2EE project in a very short period of time. In my opinion, this makes it a very good tool for Consultants that are assigned to small to medium sized, Proof of Concept like projects. Here AppFuse really shines and should be used to its full extent, meaning including all XDoclet code generation features and ant targets.
For larger projects, that will be running over longer periods of time, that have to integrate with other RDBMS like Oracle and need a clean dependency management, AppFuse can serve as a starting point. In that case though, one really has to invest the time to refactor the generated code.
One of the things we like about the Oracle Frameworks is open-ness and extensibility of the frameworks.
During our project we encountered the infamous web application problem of having two users edit the same data. The database and framework lead us to a few nice exceptions that resemble ‘RowInconsistentException’ or ‘RowAlreadyLockedException’.
The Oracle ADF Business Components framework gives us the possiblity of extending the transaction to catch this exception and do somethnig about it. We currently have decided that when these kind of exceptions are encountered that we want the transaction to be rolled back and a humanly readable exception to be displayed.
As an example we used the example of Steve Meunch (the Oracle ADF guru) and made this:
package nl.denhaag.grip.model;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import oracle.jbo.AlreadyLockedException;
import oracle.jbo.ApplicationModule;
import oracle.jbo.DeadEntityAccessException;
import oracle.jbo.DeadViewRowAccessException;
import oracle.jbo.JboException;
import oracle.jbo.Key;
import oracle.jbo.Row;
import oracle.jbo.RowAlreadyDeletedException;
import oracle.jbo.RowInconsistentException;
import oracle.jbo.ViewObject;
import oracle.jbo.server.DBTransactionImpl2;
import oracle.jbo.server.TransactionEvent;
/**
* Custom ADF DBTransaction implementation.
*
* Works in tandem with a custom DatabaseTransactionFactory implementation
* which returns instances of this subclass of DBTransactionImpl2
* instead of the default one.
*
*/
public class GRIPDBTransactionImpl extends DBTransactionImpl2 {
/**
* This framework method is called by clients to commit any pending
* changes in the transaction. It will first post any outstanding changes
* then issue the database commit to end the transaction.
*/
public void commit() {
try {
super.commit();
}
catch( JboException e ) {
handleException( e ) ;
}
}
/**
* This framework method is called by clients to validate all invalid
* objects in the transaction.
*/
public void validate() {
try {
super.validate();
}
catch( JboException e ) {
handleException( e ) ;
}
}
/**
* This framework method is invoked both by the postChanges()
* and by the commit() methods to post pending transaction changes.
*
* @param te TransactionEvent object
*/
protected void postChanges(TransactionEvent te) {
try {
super.postChanges(te);
}
catch( JboException e ) {
handleException( e ) ;
}
}
/**
* This framework method is called to actually issue the final
* 'COMMIT' statement to the database to end the transaction.
*/
protected void doCommit() {
try {
super.doCommit();
}
catch( JboException e ) {
handleException( e ) ;
}
}
private void handleException( JboException e ) throws JboException {
if( e instanceof RowInconsistentException
|| e instanceof RowAlreadyDeletedException
|| e instanceof AlreadyLockedException
|| e instanceof DeadEntityAccessException
|| e instanceof DeadViewRowAccessException
) {
rollback() ;
throw new JboException( "Een andere gebruiker heeft dezelfde gegevens ook gewijzigd. Uw wijzigingen zijn niet doorgevoerd, de nieuwe gegevens worden getoond." ) ;
}
else {
throw e ;
}
}
public void rollback() {
try {
// storeCurrencies
ApplicationModule appModule = this.getRootApplicationModule();
HashMap currencies = new HashMap() ;
String[] voNames = appModule.getViewObjectNames() ;
for( int voIndex = 0; voIndex < voNames.length; voIndex++ ) {
ViewObject vo = appModule.findViewObject( voNames[ voIndex ] ) ;
Row row = vo.getCurrentRow() ;
if( row != null ) {
Key key = row.getKey() ;
currencies.put( vo, key ) ;
}
}
super.rollback();
// reset Currencies
for( Iterator i = currencies.entrySet().iterator(); i.hasNext() ; ) {
Map.Entry entry = (Map.Entry)i.next() ;
ViewObject vo = (ViewObject)entry.getKey() ;
Key key = (Key)entry.getValue() ;
Row[] rows = vo.findByKey( key, 1 ) ;
if( rows != null && rows.length == 1 ) {
vo.setCurrentRow( rows[ 0 ] ) ;
}
}
}
catch (Exception e) {
if( e instanceof JboException ) {
throw (JboException)e ;
}
else {
throw new JboException(e) ;
}
}
}
}
It actually doesn’t do much. but enough for our purposes. For the framework you need to wrap this transaction implementation in a factory:
package nl.denhaag.grip.model ;
import oracle.jbo.server.DBTransactionImpl2;
import oracle.jbo.server.DatabaseTransactionFactory;
public class GRIPDBTransactionFactory extends DatabaseTransactionFactory {
public DBTransactionImpl2 create() {
return new GRIPDBTransactionImpl();
}
}
Even less code…
Now the magic to extend the framework: Open up your Configuration of your Application Module and goto the properties page. Scroll down all the way and find the ‘TransactionFactory’ property. Fill the with the complete classname of your own factory and presto….
Note: when using the BC tester to run your Application Module, make sure you choose the Configuration (at the top right of the screen where you select your connection) or your settigns won’t be loaded.
Via Matt Raibles weblog I found Simon Browns blog and this guy gave himself the impossible mission to compare the whole bunch of presentation frameworks that are currently available through the open source community. Colleague Rob de Jong already asked the question which framework to use and which not. Maybe Simon’s journey will useful answering this question but when looking at the ever growing list of frameworks, I’m more interested in the real drive behind these frameworks.
For example, I took a look at Mentawai (I won’t comment the name, promised ). Not mentioned in Simon’s list but plugged into the comments section of his announcement blog. Beautiful, look ma, no XML! Completely in the style of better and lighter. But, except for the configuration approach, what does it better or faster or lighter than any other framework out there? No idea.
Another example, Stripes. Never heard of it and a quick walk through the wiki documentation showed me this framework also has some original approaches not found in other frameworks. Again, look ma, no XML! This time we have to deal with annotations hell. Okay, fine, don’t like it but can live with it. But still, I can not see a reason to select this particular framework for the applications I want to build.
Maybe, and simon’s journey might be useful, somewhere in the future my opinion will change and I will actually use or even promote these frameworks, but right now I can only conclude they are primary written to fill a gap in someone’s spare time and won’t help me finding a way to speed up development.
Personally, when looking at development speed (the number of hours a developer need to spend to get something done), I do not believe in frameworks solving trival issues like request dispatching or mark-up generation. I think we need to look at frameworks who do it all (maybe supported by frameworks focused on elementary aspects like O/R mapping, security or logging). And with all I realy mean all. The complete application. Top to bottom. The full monty. Like Rails for Ruby. Yep, I took a look at Trails and Grails and somehow both frameworks could not convince me: I do not care someone is ripping a great idea but at least rip the good things and do not introduce bad ideas like annotations (Trails is using them where Rails simply uses naming conventions (in combination with a very dynamic language ) or an impossible code-deploy-test cycle (Testing Grails applications feels like waiting on a bus, step in, step out and wait for the next one). I wonder, is it me? do I miss the point? Or is it really true I’m looking for something that does not and will never exist in our world?
At the last JavaOne held in Tokyo, Sun announced that it will make Sun Java Studio Creator & Sun Java Studio Enterprise 8 available for free. This opens a whole lot of possibilities for nada.. Use Creator for your JSF needs and the Enterprise version for developing J2EE including UML 2.0 modelling..
Get it here :
Ten year ago my programming tool of choice was VI, the well known unix editor for mentally scattered and dazled software engineers. When making the jump from C/C++ to Java, Vi was still my tool. In combination with make scripts it had everything a programmer want. Yep, it had syntax colouring, auto-completion, yep it had javadoc lookup, and indeed using the right set of macro’s there were even wizard-alike ways to construct new classes and interfaces. Of course it was not the original Vi anymore, I was using the still available improved version of Vi.
Somehow something went wrong. And I do not know exactly why and when but around five years ago I found myself using a blown up ‘Integrated development environment’ instead of my favourite good old editor. When looking back it was like waking up in hell. Memory consumption and processor speed were disrupting my programming effort. The good old commandline was replaced by a repetitive strain injury causing device called mouse. And I liked it? Things got even worse. I started jumping from IDE to IDE. My first was Kawa (an ide nobody can remember anymore, not available anymore but found this year 2000 dated article about it that brings back nostalgic feelings). I did some things with JCreator, started using Netbeans and finally after two years of struggle ended using Eclipse. And Eclipse was good! Eclipse was God of IDE’s. Okay IntelliJ was better but Eclipse was free and the gap between the two wasn’t worth the money. Eclipse was the first IDE that never gave me arguments to sneakily still use my oh so beloved old fashioned but very powerful vi. And the reason for this can all be expressed in one word: refactoring!
Refactoring is re-arrenging your code all the time. Introduce new interfaces, move classes from package to package, promote methods to be part of a super class, delete classes, change method signatures and so on. It’s a way of programming, once adopted, can’t be left anymore. And eclipse was the only free tool supporting this way of engineering. Untill this autumn. Untill Netbeans released the beta version of their new 5.0 IDE. And the new netbeans has all those nifty refactor options inside. So I decided to give it a testdrive.
Using both netbeans and eclipse I’ve been doing some simple code editing the refactoring way. All coding done by netbeans, I also performed using eclipse and vice-versa. So I actually coded everything twice just to find out how both IDE’s differ on refactor options. I don’t want to give a one to one transcript of my activities but to share the impressions I’ll provide simple examples.
I started with the creation of a simple Circle class. The basic polymorphism example you find in every OO book. Give it some members to store coordinates and a radius and add setters and getters. No problems of course for both IDE’s altough the getter/setter generation wizard of eclipse can not be found in Netbeans. At least not by me but since I found out getters and setters can be generated by code completion (type setR Ctrl -Space) I use the eclipse wizard only occasionally.
After the Circle class I did the same for a Square class and while coding I discovered, how trivial, both classes share the common member to hold coordinates. Time for a super class. For this task, Netbeans provides a ‘Extract superclass’ tool which does exactly what I want. In eclipse I create the superclass by hand and use the ‘Pull up’ tool to move common members and their corresponding getters/setters. This option is also available for Netbeans but their is a slight difference: The Eclipse way of doing this is through 4 wizard screens (instead of only one) and one of those screens is asking to remove redundant members. Neat! very neat. Worth the three extra mouse clicks. Not available in netbeans. But netbeans has a very slick preview window that makes previewing the concequences of your changes a breeze.
Okay, let’s introduce som jdk1.5 features. I’ve added a ShapeGroup class wich holds a reference to List<Shape> and implements the Iterable<Shape>interface. First thing both IDE’s come up with, Netbeans after an explicit compile, are the regular compile error referring to unfound symbols. Fix imports does the trick. Eclipse comes up with a wizard per unfound class, Netbeans uses one wizard to fix them all at once. I’m still runing into compile errors because my shape group class does not implement all abstract methods. I’m missing public Iterator<Shape> iterator(). To solve this, Eclipse provide a ‘implement/override methods ‘ wizard. This wizard shows all methods of all super classes and interfaces. Simply select and go. Netbeans is missing this wizard (or again, I could not find it) but netbeans has, just like eclipse, quick fixes. Press Alt-Enter on the class definition and Netbeans comes up with the suggestion to implement the abstract methods. Works! Almost!
This is what eclipse was generating:
public Iterator<Shape> iterator() {
// TODO Auto-generated method stub
return null;
}
And this is what Netbeans generated
public Iterator<T> iterator() {
}
See the sligth dfifference! Yep the eclipse generated code does compile while the netbeans generated method does not. More important, eclipse applied generics correctly and netbeans not (see the return type). A bug I hope (or do I need to some free wrestling with code generation templates??).
I can go on with these examples, I’ve renamed classes, moved them deleted them (Netbeans has a ’safe delete’ option giving you control over the delete proces, very handy) but the results are constantly more of the same. Both IDE’s do their thing, each on its own way, but at the end I can refactor all day long without any problems.
So my conclusion is simple: the absence of refactoring tools is not an argument anymore to ignore Netbeans. They finally did it. And finally there is a good free alternative for eclipse. The next question is whether I wan’t to change IDE or not? And I have to agree, I’m hesitating. Netbeans has a lot of other pros. To name just two, very nice web development support (really love the HTTP Session inspector) and projects backed-up by generated ant files (no more build.xml coding). These things really make me happy. But on the other hand, after coding for years with eclipse, eclipse has become some kind of second nature. Difficult! On a very powerful development box (read a lot of mem) you can use both at the same time on the same project. Works! I tried it. A bit of an overkill but a provisional solution for the dilemma to netbeans or not to netbeans.
During a java meeting about the use of (open source) frameworks there were a number of interesting conclusions. Frameworks are not used for the following reasons:
- Lack of knowledge by the team members.
Most projects are fixed date. To minimize risks, projects use the known solutions (based on experiences of the team). There is no time to select and test a possible (open source) framework and estimation is already based on a known solution. Besides all that selecting a framework is not an easy task, see what-is-the-best-java-web-framework. - Dependency of a framework on other frameworks.
Some frameworks depend heavily on other frameworks. This can make configuration management a nightmare specially when having multiple frameworks that use different versions of a common dependency. - Frameworks will be outdated in a few years.
This �feeling� is based on the rapid changing java-world. A framework like Struts is now history.
When open source frameworks are not used, what is? Most projects define there own solution and depending on the size of the project this will turn out to be a project specific framework. This has one big disadvantage: new project members need to learn this framework. For this framework the same rule applies as for open source frameworks: they will be outdated within a few years.
Is there an advantage using an open source framework? YES!
There is a good chance that your project is not the only project using the framework. When new colleagues on a project have knowledge of a framework they will be productive in no time. This works best as framework selection is done on a corporate level.
Are there more advantages ?? let me know!!
I’ve previously used CVS on a few projects. It is the defacto standard for version control, stable and works very well. At this point of time i have to make a decision on using CVS again or moving towards the buzzed Subversion.
It is a though decision for someone who is not fully aware of the nitty gritty things CVS and Subversion both have to offer. That is why i am calling for help!
What is Subversion?
According to the Subversion site, it is meant to be a better CVS
That looks promising! Subversion was designed from the ground up as a modern, high-performance version control system. In contrast to CVS, which had grown organically from shell scripts and RCS, Subversion carries no historical baggage.
Subversion takes advantage of a proper database backend, unlike CVS which is file based. The Subversion team have tried to make the new system similar in feel to CVS, so users are immediately at home with using it. Most of the features of CVS including tagging, branching and merging, are implemented in Subversion, along with host of new features:
- versioning support for directories, files and meta-data
- history tracking across moves, copies and renames
- truly atomic commits
- cheap branching and merging operations
- efficient network usage
- offline diff and revert
- efficient handling of binary files
Links:
- Using Subversion on Windows (tip!)
- Subversion for CVS Users (tip!)
- Experiences with Subversion/a>
- Subversion for CVS Users
Any comments on choosing Subversion in favour of CVS are highly appriciated We can discuss frameworks probably till we die but somehow some frameworks reach the status of being a ‘defacto’ standard. And somehow this standard keeps changing more frequently than a formule-one driver can drive its laps on the Monaco circuit. That’s life, take it, leave it or be stubborn. And the last approach has driven me lately into a nice, convenient but not so ‘defacto’ stack of libraries/frameworks to develop webapplications. Warning, what will come is not enterprise, not widely used nor supported but just an experiment that proved me there are alternatives. Do not try this at work, your fellow web engineers might kill you for being obstinate. But here’s the recipy for small quick but nicely designed web-apps:
Let’s start at the bottom. The data. The famous persistence layer. All we normally use are relation databases, tables, maybe views stored in Oracle, MySQL or whatever (HSQL, Derby) RDBMS. Throw it away! The reasoning is simple, we’re living in an OO world with an OO language dealing with Objects not dealing with non OO data and heavily depending on mappings from the old world to the new world. No Hibernate, no Toplink, no Ibatis but just a a plain simple OO database. DB4O is our bottom. And yep, our bottom is going to be hit by more than one religious clan (indeed no need for EJB3, no need for DBA’s and no need for industry marketed standards, instead we simply fill in the needs to store and retrieve objects, not data).
Let’s move up to so called business logic. Nowadays business logic is living in a container. I’m from Rotterdam and the concept of containers is well known in this area. And I agree with it. Containers are great. Throw your logic inside a four by four by two meters dimensioned room and there you go. But do we need endless XML descriptors? Do we need declaretive assemblage? Not realy, I just want to program the content of my Container. So no Spring, no SEAM this time. Just a plain simple IOC container I can fill with my needs. Pico was born before Spring (and after the well forgotten Avalon framework), has a five minute introduction to explain the concepts and still works perfect.
Now, move up to the top. The presentation layer. The area where the framework war finds its real trenches. Struts has lost the war two years ago (can post a seperate blog on this issue, wont do that). There is Wicket, there is Spring-MVC and Spring Web Flow, there is JSF, somewhere there is Tapestry and of course the full pile of homegrown JSP, velocity, or whatever template based presentation frameworks. Oops, forgot to mention Cocoon in case you’ve driven into (or gets driven by) XML. And, last for not least we have to deal with the concept of rich clients (still think OpenLazlo is a fairly good option to create bling bling applicatons). AJAX is on the move and all previously mentioned frameworks are doing the best they can to support this technology. But why not use an ‘AJAX-native’ framework? Echo2 is using AJAX and supports the ‘Swing’ way of developing rich internet applications. A perfect match in the search for an alternative stack.
So, No RDMS and ORM but DB4O, no Spring or SEAM but Pico and Echo2 on top of it. Why not? Well, I can bring up plenty of reasons not to go for this stack. DB4o and Echo2 do not have real friendly licenses. Pico is coming from codehaus and not from apache. It’s a pain to cluster this stack, Echo2 eats up your HTTPSession (just like Wicket by the way) and DB4O is not Oracle. And finally it’s not standard so developers are facing a steep learning curve and first must go through a bunch of unforseen pitfalls to use it efficiently.
But, after playing for a while with this stack, I have to say its working. It’s working pretty damn good. It’s doing its job: It’s simple, It’s wel designed (pattern wise), and it boost up your performance (development wise). So why not give it a try? The last few days I’ve been experimenting with the DB4O-Pico-Echo2 stack. And to show you this stack has perspective, in the upcoming weeks (months ….) I’ll try to share some code snippets to make it clear.
By the way, before ending up in another war of flames, this post does not try to attack enterprise development using whatever framework. My previous post about SEAM still stands up! There is room for enterprise frameworks but all I would like to express is there is room for more simple approaches also! And all I like to show is that a simple approach might lead to unexpected results. The fact those results are far away from the ideas behind unreable JSR’s or other ’standards’ is no argument for not learning from it. At the end there’s a chief architect who decides and who we’ll follow. But maybe (desperate cry from a man falling of the cliffs), the same chief architect realizes he’s not doing enterprise but just small business.
So, maybe only to see what I’m talking, follow some of the tutorials that can be found on the net (db4o, pico, echo2), download the packages (db4o, pico, echo2) and give it a try to decide for yourself if this technology is applicable or not.
Download NetBeans IDE 5.0 Beta, the release that introduces comprehensive support for developing IDE modules and rich client applications based on the NetBeans Platform, the new intuitive GUI builder Matisse, new and redesigned CVS support, Weblogic9 and JBoss 4 support, and a lot of editor enhancements.
Read the full article here
