JVM level clustering, Network Attached Memory - Terracotta

Off late I have found a good JVM clustering solution with certain degree of tolerable intrusiveness. It can wash away many existing datacentre application if implemented carefully. Period. Has CISCO heard it? Incidentally I am a CISCO employee though in this blog I express my personal opinions only and may or may not be aligned with CISCO vision. Read a tutorial on terracotta at http://frameworkfactory.org/Framework_Factory/Flog/Entries/2009/8/26_Open_source_JVM_Clustering_and_Network_Attached_Memory_using_Terracotta.html

Servlet 3.0 - A comprehensive study and example

Servlet 3.0 is an overhaul to the ageing servlet technology. The features I liked in the servlet 3.0 are:
- Making web.xml optional, I really dislike handling 'BOILER PLATE' XML while coding. By using declarative style of programming(To java 5/6/7 people this is pretty old now) it is much easier and fun writing a servlet - bootstrappers will like it much. I will just show you one code snippet using servlet 3.0 that just works.

package org.objectengineering.exp.servlet3;
import javax.servlet.http.annotation.*;

@Servlet(urlMappings={"/foo"})
public class MyFirstServlet3 {
}
Thats it. Try it on a servlet 3.0 capable container like jetty 7.0. While writing this post the latest jetty was 7.0.0-pre1. Your servlet writing is over - can't believe ;) - go and deploy it now - you can skip the web.xml part. done.

Greg Wilkins proposal for asynchronous servlet is interesting and I am looking for its adoption by JSR expert commitee. The proposal can be found at http://dist.codehaus.org/jetty/misc/AsyncServlet3.0-draft0.html.

Spring Integration: the new kid on the block (of ESB?!!)

I just started exploring Spring Intrgration just day after it was released - the version 1.0.0.M5. Here I will share my first impression with Spring Integration followed by subsequent trials and experimentations. Enforcement for speration of concerns without being intrusive is something at the core of Spring philosophy and it is further extended in Spring Integration. Not to be vary theoritical but to communicate some important points about Spring Integration - I am directly copying some excerpts from officila Spring Integration reference; those are goals and principles of Spring Integration.

Goals:
• Provide a simple model for implementing complex enterprise integration solutions.
• Facilitate asynchronous, message-driven behavior within a Spring-based application.
• Promote intuitive, incremental adoption for existing Spring users.

principles:
• Components should be loosely coupled for modularity and testability.
• The framework should enforce separation of concerns between business logic and integration logic.
• Extension points should be abstract in nature but within well-defined boundaries to promote reuse and portability.

RUP Academy

=== lets make this happening ===

Review: Ten faces of innovation - Tom Kelley

I really liked the book, the way Tom described the different aspects and facets of innovation! The facets are - The Hurdler, The Caregiver, The Collaborator, The Cross-Polinator, The Experimenter, The Anthropologist, The Experience Architect, The Set Designer, The Storyteller, The Director. I agree with Tom that to be successful in innovation you have to touch upon most of the facets that he described. For this installment of writing I will talk about 'The Anthropologist'.

Atom and XMPP based team collaboration and communication platform

2 weeks back I started working on a web development project as my weekend project to experiment on Atom & XMPP. Later I was confident to forward-factor the experimentation to a real-valued project that I was thinking for a long time - a seamless team collaboration and communication platform. All the communication and collaboration can be done from just a single page.

The business driver behind the idea:

• Single page team collaboration suite




• Project status, stories and discussions are on the live dashboard – real-time, editable, provokes participation


• Developer friendly way of on-time reporting (consolidation is automatic) – just by setting the status message of your messenger/communicator


• Chat on the page


• Real time discussion on the dashboard – makes other people aware about others activities and provokes for participation. Imagine 2 guys discussing about Hibernate and is on the show on dashboard – can you take a seat back and just ignore it?


• Assign, track and manage tasks – all online


• Manage contacts – nothing new but can’t live without it


• Call contacts




• Reduces the need for email exchange – emails are difficult to track


• Open cultured team collaboration with improved communication


• You are always aware what is happening in your team - no matter who are you (although access rights can be implemented)

The salient features of this product are:
 Feed (Atom with optional RSS support) based project tracking, project story, project discussion, announcements etc.
 Presence (XMPP) based reporting – open reporting model
 Instant messaging
 Task definition, allocation and tracking
 Contacts management
 VoIP calls (SIP based)

A weekend with GWT, JavaScript & client-side xml processing using XSLT

I wanted a simple, effective, technologically advanced and appealing online test (exam) system for the trainings that I occasionally provide. I had two intentions while developing this - one, to test participants' knowledge in the topics on that I provide training - second, this weekend project itself is a demonstration of 'Assembly Line Software Development' - a post lean method - that I devised to make software development more cleaner and faster.

I donated this prototype to TME, Capgemini France - where I work as a Telco Architect in the week days. It will undergo a massive makeup and dressing room session to have more commercial features in order to make it usable for TME certification exam.

I used GWT (Google Web Toolkit) - some standard and some advanced features - and some javascript. GWT is fun to use with one disappointing thing - it does not yet support java generics and other Java 5/+ features at the client side. That means it does not have a compiler to translate java 5 specific code to javascript. For the folks not yet exposed to GWT - GWT is a sophisticated Java to JavaScript compiler with some added server side utility-ish features.

Let's just see where GWT is useful: GWT allows Java developers to write browser based application that comprises components (GUI stuffs), contents (text, image, xml etc.), events and content manipulation. A Java developer writes this in Java, allowing him/her to develop browser based application in a true object oriented way (more accurately in java way). GWT compiler translates the 'client-side' java code into cross-browser JavaScript code. It also has some server side utility-ish features - naturally that doesn't need to be translated into JavaScript.

Some quick start references 1) GWT official getting started guide 2) A good article on oracle site

The GWT features used in the the project are given below. I will write about them from three aspects - one - why I have used it, two - a brief note about the feature with reference and three - a note on how I have used it to gain some special benefit/effect.

1) RemoteServiceServlet:
Why I have used it: to serve the question set. The question set is in XML. Initially I thought to put it in the public html (equivalent) directory and thought to process them at the client side. I dropped the idea in order to avoid users' sniffing into the the questions as the questions have answers inbuilt to it for instant and easy evaluation. So... I have used this feature to serve question set from server side.

Note on the feature: At the the server side there is a service implementation that extends the RemoteServiceServlet and implements the service interface. A good place to have a look into - how to use RemoteServiceServlet is Remote Procedure Call. The catch here is to write an asynchronous interface corresponding to the service interface. Look at the above link content to understand more.

How I have used it in online exam module: The service implementation - the extension of RemoteServiceServlet - used to construct questions from XML. A question is a serialized object constructed from the said XML fragment and finally the questions - the serialized objects - put into a list and sent across to the client.

A special note: At the server side code you can freely use Java 5/6 features depending on the compiler version you are using that is not possible at the client side code. GWT 1.4.61 - the latest GWT distro - doesn't support Java 5/+ style of coding at the client side. I love using Java 5/+ features very much; specially generics.

The below picture is taken from GWT official page.


You can very well enjoy using Java 5/6 features to write server side components shown at the right hand side of the picture. I am waiting to see Java 5 related features in GWT soon.

At the client side - you instantiate YourServiceAsync is special way to get the service instance.




YourServiceAsync yourService = (YourServiceAsync) GWT
.create( YourService.class );
ServiceDefTarget endpoint = (ServiceDefTarget) yourService;
String moduleRelativeURL = GWT.getModuleBaseURL()
+ "servletalias";
endpoint.setServiceEntryPoint( moduleRelativeURL );

Now your service instance 'yourService' is ready and the operations in it are ready to be called. 'servletalias' points the implementation of the Service extending RemoteServiceServlet and is specified in .gwt.xml. Refer Remote Procedure Call for more clarity.

Architectural consideration: Simply pushing most of the processing to the client side, saving the server from crushing large data and perform more operations. There are only two calls between client and server - one - to get the set of questions and another - sending the report back to the server - not for processing but to store for future reference. For a particular exam XML (containing questions) processing is required only once at the server side after that its only functionality would be just to send the set of questions in the form of a list to the client. Efficient and simplistic - is not it?

2) UI features: This is the most used and most useful set of features in GWT.
Why I have used it: To save myself writing JavaScriot codes and making them compatible with different browser families. To be more precious - GWT has been chosen for that matter. Like many others, I am comfortable in writing Java codes, moreover it is easy to detect development time errors and correct them. Debugging is also easier compare to JavaScript debugging.
Note on the feature: The UI components are similar to Swing UI components. It is the essence of GWT but very easy to use. Refer the GWT getting started article on GWT official web page. I am not going to talk much on this as it is standard and available in detail on the official website.
How I have used it: In standard way. haha...

Special Note: I had tough time dealing with RadioButton. It made me to bang my head several times. What was the problem? The problem was a bit complicated; the behavior of radio button is just as it should be; the problem originated from my special expectation from RadioButton behavior. I used check box for the question that has multiple right answers to show the options and radio buttons for single right answer. Each selection event makes a particular flag 'true' and deselection event 'false'. In check box there are clear selection and de-selection events upon onClick() - so no problem with check box. In case of radio button - there is no event on de-selection as onClick() only can check a radio button but can not uncheck - and this behavior is required. I, then, tried to use onFocus() and onLostFocus(), it seemed to work well but did not; due to the fact when you navigate away from the group where the radio buttons are placed - it fires the onLostFocus() event that is not desirable. Finally I solved this problem with some other way. So be careful when you are frequently updating any global value based on the events captured from radio button. ;)

3) JavaScript Native Interface (JSNI): Very useful, wonderful feature.
Why I have selected this: I wanted to process XML with the XSLT at the browser end. GWT does not have XSLT processor API so I had to write a Java Method in JavaScript. Intersting... right!!! Both were new and exciting for me. Please have a look at the code I have written for your quick reference.

package com.objectengineering.onlinetest.client;
...
.....

public class OnlineTest {
...
.....
private String xmlString = "";
...

int generateReport() {
  ...
  .....
  xmlString = doc.toString();
  xmlString(); // the native method is called the way a normal
               //java method is called
  .....
  ...
}
public native void xmlString() /*-{
  var xmlDoc =
     this.@com.objectengineering.onlinetest.client.OnlineTest::xmlString;
     //the global class variable xmlString is called in this way
  var win = $wnd.open("","","");
  win.document.open("text/xml");

  // code for IE
  if (window.ActiveXObject)
  {
        var doc=new ActiveXObject("Microsoft.XMLDOM");
        doc.async="false";
        doc.loadXML(xmlDoc);
        xslDoc=new ActiveXObject("Microsoft.XMLDOM");
        xslDoc.async=false;
        xslDoc.load("test.xsl");
        var outDoc = doc.transformNode(xslDoc);
        win.document.write(outDoc);
  }
  // code for Mozilla, Firefox, Opera, etc.
  else
  {
        var parser=new DOMParser();
        var doc=parser.parseFromString(xmlDoc,"text/xml");
        var xsldoc = document.implementation.createDocument("", "", null);
        xsldoc.async = false;
        xsldoc.load("test.xsl");
        var xsltProcessor = new XSLTProcessor();
        xsltProcessor.importStylesheet(xsldoc);
        var xmlObject = xsltProcessor.transformToFragment(doc, document);
//         var xmlObject = xsltProcessor.transformToDocument(doc);
        var htmlDoc = new XMLSerializer().serializeToString(xmlObject);
        win.document.documentElement.appendChild(xmlObject);
        win.stop(); //required to solve a mozilla javascript bug
   }
//          return htmlDoc;
}-*/;
}

The native operation's code should be enclosed within the block comment.
That means if there is a method written in Java script - it should look
like
access_modifier native return_type  method_name( argunments ) /*-{
//your java script code goes here
}-*/;
If the method is 'aMthoed()' and if the return type is void and no argument then it should look like
public native void aMethod () /*-{
//your java script code goes here
}-*/

Assembly Line Software Development - A post lean method

Most of the trendy software development methods stress on either a process or documenting rigor rather than development rigor. Agile methods were able to solve this problem to some extent, but there is still a compelling need to ensure that we deliver the working software on-time with a simplistic and convenient way. Unified Processes and Agile Methods talk about chunk of working software (executable) to be delivered at the end of each iteration. After follwing unified processes, agile processes for quite a long time I have seen them failing - though there are explanations of the failures by the respective methodology advocates. While I was working on methodologies I liked some of the features of many of them and tried to fill the still-existing gaps by something of my own. I am going to list these in a form of principles. At the end I tried to devise a simple to follow and nonintrusive methodology aimed to execute rapid software delivery, which I named Assembly line software development for the time being. Assembly line was sometimes considered to be the wrong metaphor for software development - for me it depends how do we map the subject with the metaphor and I so far I have found 'Assembly Line' as the right metaphor for the way I am going to explain. The principles are not exhaustive so far and have influence from 5 broad sources 1) Guy Kawasaki books mainly 'The Art of the Start', 2) Mary and Tom Poppendieck's Lean Software Development, 3) Agile practices, 4) Unified Processes and 5)Pain of seeing failure in many projects following RUP, XP, SCRUM.

Principles:

1. Minimizing the process rigor is one. The process should be simplistic and just to ensure on-time delivery of working software. The process should be simple enough to practice. The simplicity will make the process habitual to the people use it and should not be felt as something intrusive.
2. Make meaning: do only those things that makes meaning to its users. It means figure out the way to add value. This is influenced by Guy Kawasaki and Poppendiecks.
3. Communicate & Collaborate effectively - use better communication tool that can keep the entire team in sync without disconnect. Traceable wiki, blog and IM comminication is examples of preferred communication and collaboration mechanisms. Team management along with the team should have a good policy and practice of using them regularly. Maven kind of build+management tool is also preferred to be used in collaboration. Some features like site, distributed build management are wonderful features.
4. Continuous integration - the heart of agile processes I liked it much - it is fun doing when automated.
5. Regular demonstration of working software, unit demo and integration demo - only unit test is not enough to certify 'development done' but a working demo before the review committee is a must.
6. Assembly line oriented development where everybody will contribute to one or another assembly line. There can be several assembly lines in tree structure. The root of the tree is the final assembly line and will deliver the final and complete software. Each assembly line will have different time bound slots that is a task to be done by a person - a single task - a single person (pair programming can also be applied). The deliverable(s) of a child assembly line will take part in the parent assembly line or higher in the hierarchy. This is fundamentally different from the concept of iteration or sprint in scrum. It is an open source style software development. This is more of a work pattern recognition from opensource project styles.
7. Just start working on the mission even before the goal is finalized.
8. Disposable and cooperative component based architecture: Huhh.. we have heard and worked much on reusable components but what is disposable component based architecture?? Well I'll first talk about an analogy and then will try to explain it further. Visualize a modern village, unlike multi-storied township or city-hubs, it has independent houses and bungalows; well connected but independent. The most important point is - that want to point out is - you can dispose an 'independent house' from a 'modern village' without affecting anything in village systems. In this method - I see 'independent house' as the 'disposable component' and 'modern village' as the architecture - the 'disposable component based architecture'.
9. Need for a 'real leader', a no-non-playing captain: A real leader is must in this style of software development. A non-playing captain is real no here. A real leader is not who is PMP certified or six-sigma green belt - they may have real value in some other situations/scenarios - but who 'at least' has good knowledge on technologies; technologies to work on and related complementary and competitive technologies. I said 'at least' because in a given scenario domain knowledge might be required, in those cases the leader should be knowledgeable in domain as well. Or at least a person who is keen to learn the domain fast. The leader should be able to drive the team - consider himself as one member - for 'active learning'. More explanation in active learning is given below as one of the principles.
10. Active learning: The team should always learn - learn new technologies, related technologies (complementary, competitive), relevant domains... so on.. But while learning the learner should not idly learn rather s/he should learn actively - meaning learning and doing. If it is a technology a proof-of-concept in parallel with learning, for domain - presentation (why presentation? as this method stresses on demonstration - demonstration helps in many ways; proving that you are working, and keeping the team vibrant and fostering a learning culture) of understanding and other tutorials etc.
11. Start writing code even before you understood how-to-do fully. A minimum level of what-to-do understanding should be good enough to start immediately,
12. Fill up the gap proactively - if any of the party you are depending on is delaying in giving the input about what to do - you must try to fill the gap with your own understanding rather than waiting and wasting long time; meanwhile right escalation must be triggered for the delay. Once you filled up the gap that can be communicated to the relevant/responsible parties to get approval.
13. Round table workshop: It is good to sit together in a circular table with laptops and working while having some little discussions; this will keep the team focused on what is being done - i.e. on the delivery. The team members should participate in the table at least for 2/3 hours a day; they can obviously go back to their desk or cabin whenever they feel there is a need for working alone.
14. Delay in decision: Like it is in lean method with emphasis on continuous work; meaning - the project team should start working even before the ultimate decision made by various stakeholders about how the software should look like. Here plays the role of situational leaders (explained later).
15. Situational leadership: Every team member should be situational leader - and lead the team at the right time. A situational leader is one who drives the team to do right things before the big-bosses has made up their minds.
16. A process champion - identified in a round robin fashion - who will make sure the communication and collaboration is happening in a right spirit and all the stakeholders are participationg in it. This is role is kind of evangelist's role, who will encourage people to use right communication and collaboration tools throughout the day.
17. Delivering real-value to the community: It is too philosophical, but I think everybody will understand it. Just don't do something for the sake of just-earning fat cash, but do it by delivering real value to the customer and community.
18. Build asset - I am not going to explain much about this just follow the way opensource houses build asset.
19. (To be re-arrange the above points and continue adding)
    

Hibernate (ORM) Debate - Good or bad

There are people those who hate ORM based application. Of course there are reasons for it. Personally I like ORM - again of course for some good reasons. Mostly, the people who dislike ORM, blame it for its performance. Of course there are some performance issues while using ORM - largely due to the paradigm-rift between the two worlds - object oriented and relational. But this issue can be solved - can be solved almost (if not all) entirely. The question now is how easy to solve this problem. We will see this soon in this post. When we talk about its advantages and disadvantages we tend to forget the intention of the ORM tool. To get the benefit - it is to be used in the right context where it is intended to be used. Lets see the right context. Relational technology is good for database i.e. information store, retrieval and management. Over time relational technologies got maturity and stability and most importantly it has become standard and created industry wide standards like SQL. Simply, for database - relational technology is the best - so far. For data centric application - most of the times there is a need for data model and the data model can be well developed with the relational paradigm in mind. I.e. laying out tables and their relationships. There is another important thing - i.e. Objects. Why it is required? Real world better understands objects such as a pen, a chair something that exists in the real world. To deal with real world objects we need domain model or may be in general an object model - rather I would say - it is better to use domain/object model while dealing with real world objects. Now we have two things - one is data model and other is object/domain model - two different paradigms - two facets of application development - and both are important. We need to take care of both of the facets in the direction of their implicit requirements.

Hibernate - or a good ORM tool - sits in between these two paradigms in order to connect the best of both worlds - the object world and the relational world - meant to solve two distinctive but related faces of real life applications - object oriented technologies and relational database technologies.

The major advantage of using Hibernate like ORM is to let application developers to think about business objects and largely automates the database related stuffs.

Ruby - simple yet powerful language

Like I started using blogs late; much late compare to these days young generation - I started exploring Ruby late too. In the last couple of years I was busy with SOA and its stacks from different vendors including open-source players. I was also busy to work on very complex NGOSS subjects - eTOM/SID/TNA.

Now I just started working on Ruby and downloaded Ruby on the rails. I already started liking ruby and it seems I will like Rails as well.

Good morning Kolkata!! - My first public blog..

I started writing blogs late; almost when 'blog' is a buzzword. Most of the posts here will be professional in nature with some personal touch. Today, 24th November 2007, I am in Kolkata, when I started writing this blog I was in office guest house with my wife and son and now waiting in Apollo hospital to show my father-in-law an ophthalmologist.

Kolkata has lost its warm nature in many areas but it still stands for good causes like Rizwanur and Nandigram.