You might be already aware of the fact that JetBrains have released core Intelij framework as free and OpenSource.

Although am happy with Eclipse and contrary to many people who blasts Eclipse for flaky behaviour , Eclipse have worked very nicely for me .I am quite happy with eclipse (especially with Galileo) and huge plugins for almost everything .

Still I decided to try Intelij and see what’s all are in for offer , also to see what’s new have come in since 3 yrs (last I used Idea ).

Recently I have to come up with a small desktop GUI to demonstrate an idea and thought best possible way is to use NetBeans for Swing GUI builder capabilities . Even saying that NetBeans is a good IDE is kind of understatement.

So now we have 3 very good IDE’s in java world and all three are Open Source ! This only augurs well for Java related technologies,as sometimes not the technology but the support tools around it make the last mile difference between its adoption and rejection.

So high five for Open-Source and its has kind of proved that selling commercial products in era of Open-Source would be really tough and challenging , Even if you have a superior product.

This skeleton web framework I wrote for Quarks , as they wanted a core framework on top of which they can build the applications.

As I had a luxury to design a Framework from scratch and so decided with these technologies.This dev stack is now becoming a vary dominant framework or to say in developers words “The next Popular Stack”.

Testing env I have used in this framework is TestNg , which I feel is much more suited to present day testing needs than our old JUnit(even after realese of Junit 4).

And with JDK 5+ , Spring 2.5+ which give support for Annoatations , you can have a very Simple yet very powerful framework to work with.So with this what we have is

• Spring as a Application Framework
• JPA as Persistence Framework (Hibernate as JPA impl)
• Annotation based Transactional Control.
• Spring Dependency injection with Annotation.
• Spring MVC : This can be changed if you want to use something else.
• Annotation based Validation framework.

These all elements give us enough power to create a generic and robust framework ,which can be customized for various needs.

Now let’s get to the actual work ……

Core Design Principle : The whole framework is desigend in Layers.Each Layer can only be called by layer above it and no skip hierarcy call’s are allowed.

Various Layers are

• Web : Comprises of Spring MVC & JSP , this is due to the fact that most developer in quarks are quite familiar with JSp and so we wanted to start with this.Although I am not really happy with technology choice and wanted to have GWT or Flex based GUI.
• Delegate : This is logical seperation between Web(Front End) and Service (back End).If you think that GWT or you something else suits you then this is the place where you should take a detour.
• Service : Spring based beans, annotation based Dependency & Transaction management.
• DAO : Db access layer , based on JPA and using hibernate as Persistence provider.
• Persistence Domain model : Java Beans on lines of JPA Entities.

So the principle is that a layer can only call layer below it so in this Web —-> Delegate and any call direct to say services or DAO’s should be discourged.

Another way to see this is that if we just delete a particular Layer then code below it should compile just as fine without any problem.

I wanted the package structure to reinforce this idea  .Also its easier for a new person to see as how the packages are organized . The package structure is

• com.quarks.a.web.controller
• com.quarks.b.delegate
• com.quarks.c.service
• com.quarks.d.dao
• com.quarks.e.persistence

Used a,b,c,d,e so that packages are shown in order in project view and aslo it gives clear idea of dependency in project.

Now looking at this I can easily say that DAO is only dependent on persistence pacakge.

Note : Still in edit , I’ll upload code as well . Please do give your valuable opinion about how can we have a Generic framework on this Dev Stack .

As of now am working on a fairly big  project which intended to have impact on entire bank level architecture and should be in use for more than 10 yrs .We didn’t got number 10 yrs from any mathematical calculation but it was a way to convey the message, that return on this sort of project typically comes after 5-6 yrs.

So after knowing very well that their will be many systems using your System and for  fairly long lifesapn , How do you design you Api’s ?

This particular  system is supposed to be a Cluster on Distributed Grid and will give option to other Systems to get data from Cache rather than hitting RDBMS and going forward the plan is that all System just work on top of this grid and so for them no Db calls !!

Now this systems will have fairly big outward facing Api’s and question in our mind was how to design these sort of Api’s. One important aspect of this design analysis is

What level of type safety we should have ?

Although with introduction of Ruby etc in mainstream programming , java static type saftey is preety much under attack.But my experience suggest that if you have a project on which more than 10 people will code than this is really a very important aspect to see while choosing a language . And this can be seen in Java’s success in big server side projects.

Now coming back to the point , how important is Type Safety in you Api’s which are exposed to outside world(other than your team) ?

Well answer from my side is very much , don’t give user a chance to call your Api’s with Generic Arguments.So while designing you Api’s try to be as as type safe as possible .

• Don’t take generic String as argument’s for everything and then do conversion’s .
• It really difficult to find a usecase where a method takes a argument as Object or return’s a Object.
• If you have such methods then examine them closely or this may be perfect case to show your Generics knowledge.

While pondering over this i came across this article and really enjoyed reading it ,as it reinforces the concept that your api’s should be type safe and this should happen at compile time.

Also its a good news that Criteria queries will be part of JPA 2.0 which i think was most missed feature in JPA especially when you have hibernate as persistence provider.

Right now working on this and its kind of really interesting problem

So what’s the problem we want to solve :

• Say We have a central Server/Cluster/DataStore.
• Many Clients accessing this Central thing.

Let’s take a specific case for better understanding.

You want to have a trading platform : It will consist of

• Trade booking applications : We can have mutiple apps say for Equity/Derivatives/FX etc.
• Central Data store : Resonsible for data storage and single source of data for other applications
• Middle office Systems like Confirmation Systems ,Settlements Systems etc.
• Back Office Systems.

And in out System we have a class defination of Trade : a,b,c as attributes.

Currently everybody has this Class defination and they are able to Read/Write happily.

But what if  a Client want’s to add a new field( d )to this Trade class and want to use that ?

Do all the other Clients/Central thing needs to be Upgraded as well ? For practical purposes this may not be desirable.

So then how do you design your System where a Single client upgrades to new version and its using new fields but other clients are still running on older version , its just that they don’t see the d field but can work with a,b,c .

It turned out that this is not so difficult to achieve!

The real problem is if a Client adds a New SubClass (new trade type,having extra field d ) and still other clients can read this ,same as before ,able to work on as Trade class (on  field a,b,c without knowledge of d).

Currently I am working on a Grid based Cache (Coherence) in my regular job.

The concept is that differenct System can just use the Cache and do the stuff and its very easy and fast to share information.No XMl’s being excahnged and no bickering on XSD’s etc.

The thing  is in this process we were end up writing so much similar code for Serialisation purpose (PofSerialisers) and thought the this code can be auto generated.

And with this thought in mind when we looked at the problem that our Cluster needs to support various version of our core Domain model ,let me explain this problem better :

Let’s assume we have a Trade.java class with 2 attribute and we call this versionV1 so we have T-V1.Now some new attributes are added and we have T-V2 and henceforth.But its very likely that some clients of this Cluster would not like to upgrade and would still be using T-V1 .

To code and maintain multiple versions of Data model is big task and so we decided to go ahead with concept of auto-generating the java code giving a schema file.

This is the first time i am doing something like this.Its ok to generate Stubs/Skeletons which we use in Web-Services to get auto generated but to use auto generated domain objects and this is used everywhere in project is something first time for me.

So initally our project just have Classes having business logic and these are not compilable becuase all domain classes which they use are just not their ! and when we invoke compile goal of Maven pom file ,these domain classes get generated with their Serialsers and now we have fully fuctional code which can be deployed.

I am or now should I say was happy with Ant.

It was doing all the things i wanted it to do and support in terms of documentation and other compatablity was also their.So from my prespective ,i felt absolutely no need to change to another build tool.But readin so much about maven on discussion forums and its idea about Convention over Configuration is something i always wished for.

Whenever we move to another project , its structure is the single most annoying thing.You are used to some way and now these guys are doing same thing another way.Their is no right or wrong but just diffrent and this really should be done away with.

Plus the fact that in ant you need to specify where is the ’src’ ,how to compile java file ,where test classes are ,how to generate test-reports seems bit too much.So the fact is Iwas aware of benefits maven gives but still found no compeling reason to make a switch.

This monday I needed to set up a new project and so just thought of giving maven a try.And I was able to set up a maven based project whith test-reports,PMD reports,Findbugs-reports,Coverage reports,Java-Docs etc in less than 15 min.This was awesome ,I can do all this is ant quite easily but nothing like this.

So in my opinion ‘Transitive dependencies’ is really great in Maven but its their emphasis on ‘Convention over Configuration’ ,which makes maven such a great tool to use.

Personally i am feeling bit sad as Ant used to be so cool and now it think i need some compelling reason to use ant!

I really like Agile  methodologies  especially because of its focus on  iterative development which encourages frequent inspection and adaptation.

But i would have been very happy if this was incorporated in normal working practises rather than giving a new fancy name.Now it gives a license to Managers to change requirement at any point in time and if you get back to them ,they will teach you about Agile way of doing work.

So how people have changed Agile to Fragile.

• Requirement evolves  (To)  Reguirements can change anytime and to anything.
• Document what is necessary (To) E-mail’s are good enough documents.

I am currently reading Java Power Tools , came across this book on John Ferguson Smart blog.I quite regularly read his blog as he generally writes about current java landscape and good overview of problems faced in current set up say release management,branching strategy ,continuous integration etc.

So on weekend just went out and got a copy of it from nearest Book store ‘Landmark’ in gurgaon.

After going through the index i noticed that we were using mostly all the technologies in various projects barring

a) Continuum,LuntBuild : I am happy with Hudson and no itention of switching to another CI server.

b)Openfire : Haven’t heard of it ,will try to dig deeper into it.

c)JunitPerf ,Jmeter ,Jupiter etc:We are using something else but would like to know more about them especially JunitPerf and Jmeter.

After going through couple of Chapter i noticed that this book is written in very simple and clearly demonstrated the rational behind using these technologies .May be its due to the fact that  i was already familiar with most of the technologies mentioned in the book .

In all i would recommend this book to java developer for a reference book for what’s all tools available for their arsenal.

Few things standout for me :

a) TestNG :

Author pointed this as Next-generation Testing and in my view this is very apt definition for TestNG.Junit has not kept pace with growing demands in testing space and Junit4 is also bit of disappointment.It still lacks on many features and i think way behind TestNg.

One thing i find missing in TestNg chapter is migration strategy and examples for Migrating to TestNG from Junit.But otherwise other aspects of testng were well explained like Test LifeCyclye,managing dependencies in test cases,parallel testing etc.

b) Continuous Integration :

This book cover this topic quite well and give a good overview of various tools available for this like hudson,cruise-control,continuum etc so well covered topic.

c) Profiling and Monitoring using Sun JDK tools:

Its really good to see that this book pointed out some very handy tools available to developer right under their nose ex: Jconsole is really good tool for thick client application monitoring.

I still don’t know why the tools which come bundled with JDK are not so popular inspite of such a  great use.

What this book missed :

a) Aspects :

Aspects is a mainstream concept now and could have been incorporated in this book.AspectJ have now really matured and now comes with good support in IDE like eclipse and Idea.

b) Design analysis tools :

Some insight about determining health of your current project.Some tools which can be discussed are CAP ,JDepend .

c) UML and Reverse Engineering tools :

I think this is also a topic worth considering in this book .Their are some good offerings from IBM which integrated well with Eclipse (although paid).

eUML2 from Soyatech is another good tool for UML and comes with very good eclipse plugin .

In all its a good book for getting a feel of Java landscape.

In my current project ,it seems impossible to write a Unit test case without using Mocks.And i don’t know why but i don’t like mock objects per se.I don’t know why but writing a test case with all those Mocks flying around gives me feeling that  i am not  actually testing the code but just the call hierarcy.

Their are places where mocks find their use but for me they are very few .So if you find yourself using lot’s of Mock objects and its difficult to test classes then its time you start looking at dependency injection (Spring).It really helps in making your system modular and certainly testing friendly.

Coming back to the work at hand , here ojbects dependency is specified in code and if you just need to test one method you have added then Jmock and PowerMock are your friends.

I now moved to new team in my company and task is to set a team in India which  works with london based team on round the clock model.

In process of this migration we inherited existing java code. Functionally this code is in production and is performing quite well.And this project started as small and then grown into a important big project.

Couple of points worth mentioning about this code.

• Extensive use of Static  : Or Over use of static .Writing Unit tests is big nightmare and now i can fully appreciate how dependency injection is so useful in writing Unit testing.
• Extensive use of nested classes : Not sure exact need for this kind of architecture.
• Home Grown Persistence framework.

After working with Hibernate and JDBC ,this is first time i am working a piece of code which can be dubbed as Home grown Persistence framework.Its really nice from personnel prespective after reading all sorts of problem self written Persistence framework could pose.

So am looking forward to get as much prespective on any design approach and  what prompted to be that way.

Also to compare that with hibernate .