Hildeberto's Blog

Look At It Carefully And You Will Find Something To Improve

2013-05-17T10:05:00.000+02:00

I propose you an exercise: when you come back to work tomorrow morning, navigate through the source code of your project and try to find opportunities of refactoring. Do it even if your boss didn't ask for it. Do it because you want some exciting time at work.

Refactoring is the art of changing what is already working fine. But to do refactoring you need an excuse. It could be design improvement, performance issues, security roles, and many other reasons. That's a risk you take to reduce the technical debit of the application, making it more stable and, somehow, improving your own productivity in the future.

This is not about being nice with the company or with the boss, but being nice with yourself. Why? Because problems tend to accumulate and, at some point, you will lose the control of your code. You will face hard times to deliver results and it will ruin your career.

Well, let's see this from a brighter perspective instead. You will learn a lot in the process and will soon realize that you are producing better code than you ever did before. The more refactoring you do, the more clever you become until a point where you may reach the level of innovation. But, what does it mean and how do you know you are getting there?

Innovation happens when you find a clear opportunity for improvement on what you are doing and you realize nobody else did it so far (at least you couldn't find it). That's not easy, but it usually happens when you do something repeatedly and you find yourself thinking about what would you do to do the same thing faster or cleaner. Let me illustrate this with a true story.

It was about String concatenation in Java: a classical issue stressed by numerous specialists throughout the years and probably ignored nowadays. Before JDK 1.5, despite its readability and simplicity, String concatenation using the operator "+" could produce a very inefficient code. Behind the scene, this operator was replaced by the bytecode equivalent of StringBuffer, which actually implemented the concatenation. The more you used the "+" operator the more instances of String and StringBuffer you would have in memory as well as a good amount of processing time to manage all those objects. Because of that, developers were pushed to use StringBuffer straight away and ignore the "+" operator. Look at the following example:

String title = "Mr.";
String name = "John";
String familyName = "Smith";

String message = "Dear " + title + " " +
name + " " + familyName + ",";

Developers were used to write like that, but they were pushed to write this instead:

StringBuffer sb = new StringBuffer();
sb.append("Dear ");
sb.append(title);
sb.append(" ");
sb.append(name);
sb.append(" ");
sb.append(familyName);
sb.append(",");

You may agree with me that the first example is more readable than the second one. It's just natural for developers to use the "+" operator when concatenating strings, thus it was unfair to abandon that syntax. Fortunately, compiler guys did something about it, making sure that the JDK 1.5 would optimize concatenations. Instead of using StringBuffer, a thread-safe class, they created a new one called StringBuilder (non thread-safe, thus faster) and they made sure that a single instance of it would handle all concatenations as illustrated in the first example. That's an important move because they favored elegance instead of technicalities. The first example is automatically transformed at compile time into something like this:

StringBuilder sb = new StringBuilder();
sb.append("Dear ").append(title).append(" ")
.append(name).append(" ").append(familyName)
.append(",");

However, concatenations within a non trivial logic still require you to write StringBuilder in your code because the compiler is not that smart yet. For example:

List<Student> students = studentBean.findStudents();
String intro = "The following students were approved:\n";
String listedNames = "";
String separator = "";
for(Student student: students) {
if(student.approved()) {
if(!listedNames.isEmpty()) {
separator = ", ";
}
listedNames += separator + student.getName();
}
}
String msg = intro + listedNames;
messengerBean.sendMessage(msg);

would be more efficient if written like that:

List<Student> students = studentBean.findStudents();
String intro = "The following students were approved:\n";
StringBuilder listedNames = new StringBuilder();
String separator = "";
for(Student student: students) {
if(student.approved()) {
if(!listedNames.length() > 0) {
separator = ", ";
}
listedNames.append(separator)
.append(student.getName());
}
}
String msg = intro + listedNames.toString();
messengerBean.sendMessage(msg);

Ups! Did you noticed anything strange up there? It might not be obvious at a first look, but see how they check if the variable listedNames is empty before defining the separator. The class String has a nice readable method isEmpty() introduced in JDK 1.6, but StringBuilder still uses that pretty old way of comparison. Why didn't they do it for StringBuilder and StringBuffer as well?

Discussing the issue at the core-lib-dev mailing list, it turns out there is no apparent reason why they didn't do that before. Perhaps they simply forgot it :-) Thanks to a large refactoring, trying to improve inefficient uses of string concatenation, it was possible to find such inconsistency. I believe they still have time to fix that for Java 8, which is coming out next year. And they would fix that by adding the method isEmpty() in the interface CharSequence to make sure that every other implementation will be equally elegant.

That might be a simple thing, but every single detail matters when Java is under heavy criticism for being such a verbose language. So, go for some refactoring and find opportunities to improve your code as well as the language you use to write it! Let's move Java forward!

Great Experience at Frankfurt Airport and with Lufthansa

2013-04-17T16:45:00.001+02:00

With all those crazy things going on all around the world these days, I believe sharing good news may help to compensate with good vibes all the negativity out there. It's a good thing to recognize good actions made by people around us.

Having said that, I devote this post to send a big thanks to Frankfurt Airport and to Lufthansa Airlines. I don't know how these companies are evaluated by their customers in general. Perhaps, we were simply lucky, but what has happened and the way we were treated are worth spreading.

We arrived at Frankfurt Airport in an United Airlines flight coming from the US (I have nothing to say about this company btw :-/). We were three: My wife, my one year old boy and I. The airport is enormous, but it couldn't be easier to get directions inside. We experienced good accessibility carrying our baby's stroller, with a negligible delay in comparison to other ways.

Everybody was genuinely gentle, from the immigration to the arrival in Brussels. No silly jokes, no excessive friendly behavior, just fine :-) That was the first contact we had with those people, thus they have no reason to exceed kindness, unless they were selling a false image of the company, which they didn't. We actually felt relaxed dealing with those people. We needed that after a exhausting 8 hours flight from the US.

Our baby arrived at the airport sleeping and stayed like that until Brussels. That's what I call the smoothest flight connection ever :-) The baby spaces are separated from the toilets and they are accessible within a range of 50 meters maximum. The security check has a special track for people with strollers and wheel chairs. We followed the procedure calmly and fast :-) All that is so convenient!

Even things that rarely work were working that day :-) We didn't have our seats marked in the flight to Brussels due to some technical problems during the reservation. We were afraid to have seats far from each other and be forced to negotiate rearrangements within the airplane. Fortunately, the attendant managed to put us together. It never happened before! I may admit we were lucky ;-)

It couldn't be better until the boarding time when our expectations were exceeded! A lot of first and business class people around and the attendant called us to be the first ones to enter in the airplane. She called us out loud using the microphone and explained to other passengers that the baby would require some extra effort during boarding and it would help to gain some time after all. I call it intelligence and good judgment because that's exactly what I would do in her shoes :-)

Unfortunately, many airports out there banned such practice, which is the case of Brussels Airport and Washington Dulles, the ones we have been with our baby. Those airports following such stupid rule should give attention to families with babies and people with disabilities because this is not a privilege to a minority, but a necessity. They ignore the fact that it's tough to travel with a little baby. Thanks to Lufthansa, we arrived very relaxed in Belgium, with a big smile on our faces :-)

Interviewed by Java Magazine

2013-03-27T11:40:00.001+01:00

The March/April issue of Java Magazine is released! You should definitely check this out!

By the way, they actually published an interview we did some time ago, together with Bruno Souza (SouJava, Brazil) and Michael Huttermann (Jug Cologne, Germany). That's cool! But I'm not a big star as they are, just a Java passionate guy! I do appreciate that! You can read the interview in the picture below or directly in the latest edition.

Many thanks to Java Magazine's editors for publishing that interview!

On The Illusion of Controlling People's Time

2013-01-27T17:41:00.000+01:00

Software Engineering is going through an identity crisis. The old school has failed because of too much control, moving people away from what they really have to deliver. The new school, or agile fever, is more focused on humanities, directing all the attention to human beings. This approach practically decimated the old school, showing that writing software is not an exact science. It is actually unpredictable and cannot be done without creativity, inspiration and transpiration. Maybe the old school, which insists to exist, got confused by the fact that software execution, data processing, and system and hardware design are engineering stuff, but it doesn't mean that developing those stuff is also engineering. On the contrary... it's human and social.

When I see managers trying to measure the time spent on people's daily activities, I understand they are taking into consideration only the transpiration of their teams and completely ignoring the creativity and inspiration. These two last aspects are so subjective that it's hard to compare their manifestation on different people. How to compare artists? We may find artists' comparisons out there, but they heavily rely on who is producing the comparison. Let's ask ourselves: why on earth would someone use quantitative criteria, such as time and money, to measure and compare subjective matters?

Measurements are only useful when we're capable of making comparisons with them in an objective way. We compare the date of our birth with the calendar to know our age. In times of crisis, we pay attention to our water, gaz and electricity consumption and make comparisons, finding ways to save money. Climate is measured because we need to decide which clothes to wear or which precautions to take by comparing with previous experiences or common sense. Notice we put measured subjects into perspective to understand the real dimension, the scale, the direction, and then we're able to reason about trends, behaviours, issues, patterns, etc.

When it comes to subjective matters, we might be able to make comparisons, but measurements are just useless in this case. Actually, we can come closer with a lot of statistical methods, multi-variable analysis, multi-criteria craziness, but do we really have time and resources to produce all these analyses in a daily basis, and even take the risk of being probabilistically far from what it's expected? It sounds complicated, isn't it? That's because it is. :-)

In software development, every activity is different from one another. It's impracticable to precisely compare two activities even if they look the same and are done by the same person. It's all subjective, otherwise it would be easy to put the project on schedule by adding more people in the team. We know that since 1975, when Frederick Brooks published "The Mythical Man-Month". So, when a manager asks their developers to inform the time spent in every activity, he/she is in fact collecting lies (or non-truths). If he/she prepares a report with those collected times, this is going to be the spread of an even bigger lie (or useless information).

But why lies? There are two good explanations for that:

most people don't track exactly how much time they spent on their activities, thus they actually inform safer figures, which are usually higher than reality;
time control gives a feeling of surveillance, making developers believe their manager wants to know whether they are really working or not, thus they smartly add some extra time to mask non-productive time.

Managers should also be aware that time control also kills creativity. When developers have new ideas, potentially useful for the project, they cannot simply turn them into activities because of scope constraints or just because those ideas are not clear enough to be described. Without activities, developers cannot report their time. Therefore, if they spend too much time working on their ideas, it will look like huge time gaps for their managers.

Eventually, managers are moved to implement time control because of visible procrastination. I remember once when a new project was starting, a big room was allocated to a team of 12 people, and the project manager asked the team to choose their places in the room. There were 15 places available, 12 with monitors facing the wall and 3 with monitors facing the door. Guess which places were left available? That's right! The three ones facing the door :D I remember the symphony of mouse clicks and sudden movements when the manager walked through the room. That was so funny! :D But time control wouldn't solve that problem because inputing time on activities is also a distraction. Anything that is not building deliverables is a distraction. We may never eliminate them, but we can always reduce them. The solution for procrastination, in a single word, is: Motivation!

But, is time control totally out of sense? It has some sense when the work is fully based on time, which is the case of consultants payed hourly. This is about their business model, not software engineering. That's a good practice for consultants to inform to customers how many hours they had spent because it's directly related to their payments. Notice that this kind of service is for a short period of time and for highly specialised skills. However, we are talking about software projects that last longer.

Finding ways to motivate your team is the best strategy to put them on track and fully productive. Every form of control that threats their feelings will put them down. Motivation doesn't need to be monetary or entertaining. Sometimes, it's enough to show their wins, how important is their work for society, how it changed people's lives, and why it's important to keep doing what they're doing.

"One reason programmers dislike meetings so much is that they're on a different type of schedule from other people. Meetings cost them more. For someone on the maker's schedule, having a meeting is like throwing an exception. It doesn't merely cause you to switch from on task to another, it changes the mode in which you work." - Paul Graham

Featured on Oracle's Java Magazine

2013-01-26T15:08:00.001+01:00

I'm glad to see I was featured on the latest edition of Oracle's Java Magazine (Issue January/February 2013, page 67). I would like to thank Oracle on behalf of the CEJUG Community. We have been partners for so long and this is a nice way to demonstrate that you guys, at Oracle, recognise our contribution to the Java Community.

It's important to say that they cut part of my hair using Photoshop. I'm actually more handsome than it looks like... hehehehe :D Joking! Back to work!

Leaving CEJUG's Leadership Team

2012-12-31T18:33:00.000+01:00

Today is my last day in CEJUG's leadership team. A journey that lasted for tireless 8 years or something. I'm not sure about the exact date I became Jug Leader, but I remember very well how it happened. I was attending a CEJUG coordination meeting at Fortes Informática because I was helping them to organize an event. Right after the meeting, Felipe Gaúcho invited me to co-lead the group, which was unexpected but very pleasant. I accepted immediately! Felipe is not among us anymore, but I am eternally grateful to him for this incredible opportunity.

I'm not leaving because I'm tired or bored. I'm leaving because CEJUG needs renovation. It needs to change its philosophy, its soul. I'm the oldest one in the leadership team, thus I'm a dinosaur in terms of community management. My mind still believes in some practices that don't work anymore and the community is not growing as it could grow. Fresh and valuable ideas usually come from new people with a vision to help others to develop their technical capabilities. I'm sure there are a lot of people like that out there and I wish they get my place and move on faster.

There is a CEJUG's rule that promotes ex-leaders to become advisers for the leadership team. It is a sort of recognition for the great services provided to the group. But I'm not accepting even that. To give advices to a future leader is like bringing back the old way of thinking. That's what I'm trying to avoid. Advisers are not so active anyway. I don't remember the last time I received an advice from them. Actually, it ended up becoming a definitive leave for them too. Eventually, my departure will motivate other members of the leadership team to take the same initiative, if they have the same feeling I'm describing in this post, of course.

Sometime ago, a friend of mine was excited about CEJUG's community and he asked me what he has to do to become a JUG Leader. I told him that it's not so difficult, but it requires patience and a lot of work. That's because CEJUG is a meritocracy, where you are recognised according to your contribution to the community. The recognition is basically promoting you to the leadership team, then you have more power and resources to make things happen. It takes some time because we wanna make sure that you won't give up easily and you will just continue working as hard as before.

The problem is that there is no glamour in the role of Jug Leader. New leaders probably realised that it's more a labor of love, donation and dedication than a professional achievement. Some people love that, like I do, but most people don't. Perhaps new leaders won't find motivation for the merit in this meritocracy model. The excitement may last for a few months and then, even the free time will be occupied with other priorities.

I have been proud of my role as a Jug Leader, not because of what I did for the community, now and in the past, but because of what I feel for them and what I was willing to lose for them. I will keep this feeling in my heart. You may ask me why I'm leaving since I'm still in love. This is like a relationship that doesn't work. When your love is not reciprocal the best thing you can do is set your love free.

If you want to be the next CEJUG Leader, be aware of the need for passion, donation and dedication, with or without professional achievement. In addition to that, read a very interesting post on John Yeary's blog about the definition of a Jug Leader.

By the way, I will continue as a humble CEJUG member, trying to help people there with their technical questions. Meanwhile, I'm working on a new open source project! I'm going to launch it here soon and maybe it will end up in a new, large and successful community! ;)

Easier Multi-Field Validation with JSF 2.0

2012-12-23T18:25:00.000+01:00

One of the most frequent needs when developing application forms is multi-field validation (or cross-field, but I'm not using this term because when I put it on Google I actually got some post-war pictures). I'm talking about situations where we need to compare whether an initial date is earlier than an end date or a value is lower than another one. Isn't it an obvious feature in every business-oriented framework? Not really. Unfortunately, the JSF specification doesn't support it by default. Therefore, until its latest production release (JSR 245 - JSF 2.1), JSF did not offer an out-of-the-box multi-field validation feature.

We probably can hope for something coming in JSF 2.2, since the JSR 344 mentions "Multi-field validation". Meanwhile, developers have used their fruitful creativity to implement their solutions. You can find plenty of working alternatives at Stackoverflow.com; people creating their own components; frameworks built on top of Java EE trying to cover this feature; and many other cases.

I didn't like any solution I found. Some are complex, others are not so elegant. So, I decided to be creative as well and try a simpler solution, easy to understand and change when the time for refactoring comes. It doesn't mean that I'm proposing something better than other proposals. I'm just proposing something simpler.

In the following example, I check whether an allocated budget is smaller than a budget limit. If not, then a message is shown to the user. The example considers only two fields, but it can scale to as many fields as you wish.

Step 1: create an attribute in the managed bean for each field to be validated:

The attributes below are exclusively used in the multi-field validation.

private BigDecimal validationAllocatedBudget;
private BigDecimal validationBudgetLimit;

In this example, I'm coding inside a class named MBean, annotated with @ManagedBean and @RequestScoped.

Step 2: create a validation method in the same managed bean for each field

This solution considers validation methods implemented in the managed bean instead of implementations of the interface javax.faces.validator.Validator. You can give any name to validation methods as long as you define three standard parameters, which are the FacesContext, the UIComponent, and an Object representing the value input in the field. Only the value is useful for our validation. See the validation methods:

public void validateAllocatedBudget(FacesContext context,
                       UIComponent component, Object value) {
   this.validationAllocatedBudget = (BigDecimal) value;
}

public void validateBudgetLimit(FacesContext context,
UIComponent component, Object value) {
   this.validationBudgetLimit = (BigDecimal) value;
   if(this.validationBudgetLimit
.compareTo(this.validationAllocatedBudget) < 0) {
       throw new ValidatorException(
new FacesMessage("Invalid allocated budget!");
   }
}

The method validateAllocatedBudget doesn't validate the allocated budget. It simply set the attribute validationAllocatedBudget to allow its value to be used afterwards. It is possible because the validation methods are called in the same sequence they are declared in the JSF code. So, you can create a simple method like that for each field involved in the validation. The effective validation occurs in the method validateBudgetLimit, which is the latest called validation method in the JSF file, thus the last one to execute.

It's a good idea to declare attributes and validation methods in the same order of the fields in the form. The order doesn't interfere the functioning of the algorithm, but it helps to understand the logic. On the other hand, the order of calls in the JSF file is important.

Step 3: use the parameter validator to reference the validation method

The methods described above are called from the fields below. Remember that the attributes and methods were implemented in the class MBean.

<h:outputLabel for="allocBudget" value="Allocated Budget"/>
<h:inputText id="allocBudget" label="Allocated Budget"
value="#{mBean.operation.allocatedBudget}"
validator="#{mBean.validateAllocatedBudget}"/>

<h:outputLabel for="budgetLimit" value="Budget Limit"/>
<h:inputText id="budgetLimit" label="Budget Limit"
value="#{mBean.operation.budgetLimit}"
validator="#{mBean.validateBudgetLimit}"/>

That's it! :) Merry Christmas and Happy New Year! \o/

Case Study: Migrating a Large Project from Ant to Maven

2012-12-18T10:09:00.001+01:00

The truth is we had been under difficult times. We spent almost three months to migrate our build mechanism from Ant to Maven. That's the minimum time you have to put in your schedule if you are planning to do the same in a large project. There are still some collateral effects of this migration that we are struggling to solve, but fortunately they are not so critical.

The Context

Just to contextualize a little, we have a full Java EE 6 system composed of 25 integrated applications and each application has an average of 3 modules (EJB, WEB, etc), reaching ~80 modules. We manage something close to 500K lines of Java code (JSs, CSSs, JSPs and JSFs files not included), according to our Sonar analysis. It takes between 15 to 20 minutes to build everything. It depends on the mood of the server.

The decision to go for Maven came as a precondition to start a large scale refactoring of the application, which, despite using the latest technology available (Java EE 6), has suffered from a mix of frameworks, design flaws and multiple architectures over the years. We are going towards a single architecture grounded on the Java EE specification in order to optimize dependencies, reduce the evolution cost in a middle/long-term perspective and run seamless in our Glassfish Application Server.

The Duty

The project structure is almost the same as it was with Ant, thanks to the flexibility provided by Maven. We have a super pom.xml file in the root folder, which basically declares all modules, plugins, additional repositories, and dependencies. The dependencies are declared in a dependency management (using the tag <dependencyManagement>). This way, all version numbers are declared in a single place. Besides the super pom.xml, we have a folder for each integrated application and inside each folder we have a application pom.xml and three other folders, one for each Java EE module (EAR, EJB, WEB). The application's pom.xml inherits from the super pom and it basically declares the modules composing the application. Inside the module folders we have one more level of pom files. These pom files inherit from their respective application's pom files and describe the particularities of their modules. In summary, we have three levels of pom files, from the system as a whole to the level of Java EE modules.

Example of structure similar to the one we are using.

For development purposes, we avoid deploying the entire application locally. That's why we have an EAR module in each application. This way, we save time deploying only the application we are working on. Those application EAR modules are not taken into consideration when packaging to deploy on the servers. To build the full EAR for the servers we have a special application that contains a EAR module, whose pom file declares all EJB and WEB modules as dependencies. Performing the goal package on this pom.xml will actually create the super EAR file.

EAR module to package the entire system in a single deployment file.

The Good

Evaluating the project after Maven implementation, we could notice the following benefits:

Maven contributed to simplify the logic behind the build: Now, everybody is aware of what is going on because pom.xml files are much easier to understand than build.xml files. Our Ant files were generated by Netbeans, thus very big and unreadable. We were actually lucky to have them working for so long, since it was difficult to maintain them. No question that we would find a point of irremediable chaos very soon.

Maven also contributed to put some order in all project dependencies: We went from a ~100 MB EAR package to a ~50MB one, a very significant reduction of 50%. It contributed to make the deployment time shorter.

We had the opportunity to clean up the project: While gathering the dependencies to write the pom.xml files, we discovered that some modules were not needed any more; libraries spread through the modules were also removed in favour of Maven's dependency management. In summary, we have said "Maven is a nightmare" until the day we finally had everything in order and we became happier and relaxed. That's what most people say as well, since it's not easy to find solutions for a particular scenario, and everybody has a particular scenario to deal with.

Short learning curve: Once Maven was put in place, we visited all developers, reconfigured Netbeans to recognize the Maven projects and explained to them how to proceed from that point on. All of them could immediately continue with their development activities and just a few call for support were triggered. None of these calls were blocking issues. I have to say that Netbeans contributed a lot to reduce the learning curve because all necessary goals are performed directly from the IDE and there is no need to go to the command line, as it usually happens with Eclipse.

The Bad

Unfortunately, we had some setbacks:

The build now takes longer with Maven: We have noticed a decline on developers' productivity due to that, making us a bit frustrated at the end :-( Since we are not going to rollback to Ant, we are considering JRebel for dynamic reloading of changed code to compensate the additional time we are spending.

We are using some libraries that can't be found in Maven's central repositories or elsewhere: Some are commercial libraries and others are too old. We also found libraries available with inconsistencies, throwing many exceptions at runtime (i.e. Apache FOP). For each one of these situations we had to find workaround solutions that were not so elegant, but we cannot stay like that for so long. We have to install a local Nexus repository to address special cases. This is in our check-list.

Occurrence of unexpected behaviours: the best of the efforts is not enough to avoid unexpected behaviours in the application. We have built a spreadsheet listing all applications and their respective modules; documented all dependencies from libraries and between modules; depicted the project structure; went deeper into details. In order to elaborate this spreadsheet we spent several days investigating the guts of the system, absorbing low level mechanisms and design decisions. All the collected information was used on the migration. Nevertheless, the rearrangement of dependencies and the removal of duplicates and unused libraries caused broken navigation flows, alert messages coming from nowhere, changes on URL paths and many other surprises. Unfortunately, we couldn't predict those problems and we spent much more time on fixes than what was initially foreseen.

The Conclusion

I would like to conclude giving some advices for those planning to adopt Maven in a middle/large scale project:

Communicate the migration to end-users: it's very important to communicate to end-users what is going to happen in the coming days. Users should be aware that, as they have the duty to improve their business, we also have the duty to improve ours. It means the delivery of new features will temporarily slow down to pave the way to a better product with faster releases. If they are not aware of what is going on, they will have very low tolerance to problems, undermining the reputation of the project.

Don't be afraid to change even what is working well: We have questioned ourselves why to migrate to Maven if Ant is working so well. Actually, our strategy is to reduce complexity to streamline the resolution of problems. So, we were not afraid to migrate because preventive measures are very important too.

Keep the entire migration under version control to help the investigation of problems: Once all pom files were created and versioned, every little changes in those files should be committed separately in order to revert changes in case of unexpected problems. It helps to isolate the causes. It is also good to know that there is no conflict between Ant and Maven files. So, both can stay in the same branch during the migration without any impact on developers.

Don't start a big refactoring without a build system like Maven: a successful refactoring depends on a detailed understanding of the application and adopting Maven will push you to perform an extensive investigation. In addition to that, the project will be cleaner and better organized.

There are other alternatives to Maven, such as Apache Ivy and Gradle, but, despite all deserved criticism, we still recommend Maven when replacing Ant because of its maturity; vast plug-in portfolio; abundant documentation on the web; and rich IDE support. However, it's a good idea to evaluate other alternatives once Maven is put in place. After the initial tsunami, other waves will come quietly.

Freedom of Thinking and Speech at Devoxx 2012

2012-11-20T13:10:00.000+01:00

I have been attending Devoxx in a row since it was called JavaPolis and then they had to change the name to Devoxx due to copyright issues with Sun Microsystems at the time. I have the privilege to live close (in terms of world, but far in terms of Belgium) to the hosting city, Antwerp, and I'm used to be passionate and engaged with the Java international community. However, the main reason I'm successively attending this conference is because they excel every edition, making the next one unmissable. This year it wasn't different.

Stephen Janssen trying to find 200 available places in that crowded geek audience.

Devoxx is probably the only conference in the world that manages to put Oracle and Google face to face without conflicts. This is such a great achievement that I would recommend Devoxx's team to the United Nations in order to address the conflict in Gaza and finally put an effective peace process in place between Israel and Palestine ;-)

By the way, I should say something about the way Oracle leads their keynote speeches. Last year Oracle made a pretty boring presentation, but it was ok after all. This year they exceeded themselves making a pretty boring + chaotic presentation. First, Nandini Ramani, vice president of engineering, Java client, and mobile platforms at Oracle, was clearly nervous on the stage. At some point, she called Stephen Chin to join her and he didn't show up. Ups! She decided to jump to the next presentation, which was clever, but right in the middle she was interrupted by the sound of a motorcycle, causing a pretty awkward moment. What?! :D Yep! We initially thought that the staff accidentally opened a door, bringing noise from the traffic, but in fact Stephen Chin suddenly came out with the motorcycle used in his Night Hacking Project. That was actually pretty cool except by the fact that Nandini was completely taken by surprise. She couldn't handle that unforeseen situation and she just handed over to Stephen, leaving the presentation halfway. Still, we had a lot of fun watching the situation. :D

On the other hand, Google made a great tech show! Wow²! They know how to hold the audience's breath. The only issue (at least for those urging to visit the toilet) was their inability to manage time. The presentation took longer than expected, but every second was pretty well spent on exciting demos! Cool!

So, what do I learn from that? From my perspective, I see Devoxx as a great independent conference where it's possible to closely compare leading competitors and make realistic decisions about the technologies we are going to chose for the coming years. Devoxx is definitively the best alternative to avoid brainwashing conferences such as JavaOne (It wasn't like that in the past). This is to say the least, because they managed to overcome our expectations by adding a special track named Future<Devoxx>, focused on the programming of tiny devices, such as TinkerForge, Arduino, Raspberry Pi, and others. Curiously, there wasn't a single mention to the classic SunSpot, which is probably one of many nice projects killed by Oracle after acquiring SUN. That track added a world of possibilities to all those entrepreneurial minds. Well done!

Is that all?! Not yet. Mother Devoxx is going to have a new baby next year! After Devoxx France, they announced Devoxx UK. Yeah, attending Devoxx became a touristic problem now, based on the city you wanna visit ;-) Last, but not least, Devoxx4Kids is definitively a great initiative! I actually wanted to attend it, but I have to wait for my little boy, who is only 11 months old now. I'm giving him twice more milk to watch him grow up faster :P

JavaFX Must be a Joke

2012-11-18T10:13:00.002+01:00

More than 3 years ago, I wrote the post "Has JavaFX a Strategy?" saying:

"Don't you think that the fastest way to spread the JavaFX adoption is allowing the improvement of existing applications? Why to spend a lot of resources to drag an applet from the browser to the desktop if we need the network anyway?"

At that time, JavaFX Script was the only alternative to develop richer Java desktop applications. Guess what Oracle did right after Sun's acquisition: they stopped evolving a pretty stupid new language which looked more like Json, which is designed for data; migrated the whole thing to a new Java library; and allowed the integration with legacy code (i.e. Swing applications). If they didn't get inspired by my old blog post, then they just followed the sane common sense.

Meanwhile, Adobe gave up Flex and Microsoft gave up Silverlight. Strangely, Oracle kept insisting on JavaFX. We can see a lot of JavaFX demos out there, but not so much production-ready apps. That's a shame after all these years. The single example I have of a real world application is from a Belgian company called Health Connect. That's all! Anybody else?! JavaFX evangelists would give a lot of confidence to Java developers if they promoted JavaFX applications in production. We have the impression that those evangelists are paid to have fun. This is really unexpected from Oracle, which looks like a very serious company. Take the example of Apple. They are very efficient on that. Every time they present their gadgets they also present outstanding apps developed for that device. It definitively makes developers excited!

Fake announcement of JavaFX for
the mobile world in 2009. Since then
zero apps shipped so far!

I was about to be excited when Oracle announced JavaFX running on OS6 with an app called JavaFX Ensemble, but when I realised that the goal of the app was simply to add more demos to the shelf, I got immediately frustrated :-( Is it so difficult to convince a company out there to write a useful app in JavaFX and make it available on OS6?! Come on! We are tired of demos! In fact, this "alpha" project is not enough to convince us that Java is going mobile. In my previous post I made the following prediction:

"... in 3 or 4 years there will be no Java on devices, and the development community will have enough knowledge to live with that. Therefore, Java will be basically a server-side technology."

Now, let's imagine that JavaFX is a great technology and everybody is adopting it. Is everything ok now? Nooooooo! Even if everybody is convinced about JavaFX, there is no stable, reliable and easy to use JVM out there for the client side at the moment. Therefore, we cannot efficiently distribute JavaFX apps on desktops. We have to be within a company, with full control over the network, to manage the installation, security and upgrades of the JVM in all desktops in order to distribute the application. Well, that's silly :-/

Error during my latest attempt to update my JVM.
Message: "Failure to download required files for installation."

I'm quite confident to advise you to leave JavaFX aside and go for HTML5. Most of its features are already cross-browser compatible and it's possible to build amazing user interfaces with that. Client-side Java is over, so get used to an exclusively java server-side world soon. Surprisingly, it doesn't make me sad, but happier :-)

The Consequences of Deferring Project Jigsaw

2012-08-31T11:33:00.000+02:00

Mr. Mark Reinhold has announced in July 2012 that they were planning to withdraw Project Jigsaw from Java 8 because Jigsaw would delay its release, planned for September 2013 (One year from now). This date is known because Oracle has decided to implement a two years roadmap planning for Java, so September 2013 is actually 2 years after the release of Java 7.

According to Jigsaw's website...

"The goal of this Project is to design and implement a standard module system for the Java SE Platform, and to apply that system to the Platform itself and to the JDK. The original goal of this Project was to design and implement a module system focused narrowly upon the goal of modularizing the JDK, and to apply that system to the JDK itself. The growing demand for a truly standard module system for the Java Platform motivated expanding the scope of the Project to produce a module system that can ultimately become a JCP-approved part of the Java SE Platform and also serve the needs of the ME and EE Platforms."

They also say:

"Jigsaw was originally intended for Java 7 but was deferred to Java 8."

Now they want to defer it to Java 9 :-( More details of their decision making are available in a Q&A post on Reinhold's blog. You may read and follow the discussion there. Here is my opinion:

Without Jigsaw, I believe that it's very difficult to put Java everywhere. Without Jigsaw, the idea of multi-platform is getting restricted to servers in a age of smartphones and tablets. Jigsaw may be "late for the train", but it is letting Java late for the entire platform ecosystem.

Deprecated installation screenshot

Observing the market, we can see that development is becoming platform-dependent (iOS, Android, etc.) Only Java can beat this trending because of its large experience on multiplatform implementation, and the time to do it is NOW! Otherwise, in 3 or 4 years there will be no Java on devices, and the development community will have enough knowledge to live with that. Therefore, Java will be basically a server-side technology.

The reasoning behind my prediction is the following: mobile devices are limited in terms of resources and a modular JVM would allow the creation of tailored JVM considering the constraints of each device. I put myself in the shoes of those devices manufacturers: "I wouldn't distribute something in my products that might impact negatively the user experience in terms of performance". That was the argument (at least the public one) Apple used to avoid distributing the Flash plugin for iOS's browser. Probably because of that, Adobe definitively gave up Flash on mobile devices. A modular JVM would simplify a lot Oracle's negotiation with many device players. It would be reasonable for Apple to include Java as a language for iPad and iPhone applications; Google would finally embed the JVM into Android to evolve faster with new Java language features, getting busy just with a module to extend the JVM to specific Android's capabilities; it would be even possible to save Nokia from bankruptcy :D

You may wonder whether Apple and Google would ever adopt JVM as a standard runtime platform. Have you heard about opportunity cost? It states that our current choices and activities are actually blocking other possible choices and activities. The tricky part is to chose the opportunity that is least costly or with the highest profit. Having said that, we can see the scenario considering that Java was not an option because it wasn't modular when those companies made their decisions. If Java was modular and Apple had adopted it, iOS platform would have at least three times more apps than Android. "Java" was in Google's strategy to catchup with Apple. Only Java could allow Google to do it in such a short period of time. So, it's not so simple to ignore Java.

Now, Oracle vs. Google: Of course the effort to move Java forward should be economically viable, and in order to use Java, Google would have to spend some money. Unfortunately, Oracle and Google work with different currencies. While Oracle thinks in terms of licenses, Google thinks in terms of advertising. These currencies are incompatible, very difficult to convert, because while license is cost, advertising is profit. Therefore, Oracle would never reach a deal increasing Google's cost, but it would be possible to get a deal decreasing Google's profit. In other words, Oracle could have a percentage of Google's profit on advertising sold through Java apps in order to make Java available for Android. Google makes this kind of deal with a lot of companies like Yahoo, AOL and others. Why not with Oracle?

If Oracle doesn't give all resources that the JDK team needs to make Jigsaw a reality in Java 8, Oracle will be completely out of the pervasive game very soon. Without breaking the JDK into manageable and efficient pieces, Oracle won't have arguments to convince the industry that Java is the way to go on the long run.

Before deciding to drop Jigsaw out, I beg Oracle to think about the consequences! They must ignore the fixed release roadmap and accept the difficulty of the task. We can stay happy with Java 7 (it's not widely adopted anyway) as long as Jigsaw is on the way to Java 8. This fixed release cycle can actually come back after Java 8.

I would love to be wrong and be taken by surprise with an official Oracle's announcement of the definitive support for JavaFX on Apple and Android devices during the next JavaOne ;-) However, I think the likelihood is very low :-(

Book Review: Programming Collective Intelligence

2012-07-08T13:37:00.002+02:00

When the volume of data managed by our application significantly grows, we start thinking about ways of extracting information from the databases. We know that there are a lot of hidden information there, but we don't know exactly what they are and how to get them. Year after year, people have been working on solutions such as data mining, data-warehouse, business intelligence, and others to figure out those hidden information. At the same time, people also look for ways of using those new information not only for reporting, but also to give constant feedback to the application in order to achieve better results over time. This looks very much to a self-learning mechanism, that we can formally call machine learning.

Nowadays, a new dimension are absolutely relevant when applying machine learning on data analysis: the user's behaviour and preferences as individuals and as part of the collectivity. This is clearly the influence of social networks on all sort of applications. They are exploring new possibilities of improving the user experience, but how can we be part of that party? Do we need to get a PhD degree to follow the wave? Is it finally possible to make the subject accessible to ordinary programmers? No, we don't need a PhD degree and yes, it's finally possible to make our applications smarter. This is what I've noticed while reading the book Programming Collective Intelligence, written by Toby Segaran.

At the beginning, I felt uneasy with the chosen programming language - Python - but I was gradually getting used to it because Python is not that hard to understand. In any case, I think this book would reach a larger audience by writing the examples in Java, which is constantly fighting with C for the first position in a well known ranking of popularity. On the other hand, the book targets more websites/portals and we know that Java is not really the first choice when companies decide to develop an application for a larger audience. Independent on the programming language we master, we can always convert what we've understood from Python to our favorite language. At the end, the success when implementing those machine learning algorithms come from our ability to solve computational problems, not from our ability of learning new programming languages.

On which concerns the content, the book brings together a large variety of real world problems from websites and services that we frequently use. It concludes reviewing and comparing the described algorithms, helping the reader to easily visualize the applicability of the different methods and to decide which one is the best for the problem we are actually facing.

This book has a new and better approach to present complex subjects such as data mining, machine learning, and statistics. By contextualizing the subject with real scenarios, the author improved the didactic in an unprecedented manner, since this is not the case in academic books. Actually, Programming Collective Intelligence can also be used by undergraduate and graduate students, since there are exercises at the end of each chapter. This is great because sometimes we finish the study of a chapter without realizing what else can be done with those algorithms. This is not common in this kind of book (non-academic) and yet very appreciated.

Architects Need a Pragmatic Software Development Process

2012-06-30T07:24:00.001+02:00

I have been a non-stop software architect since 2006. During my experience, I realized that it’s really hard to perform the role of architect in an organization that doesn’t have a software development process or have it too simplified. When the development is not fairly organized, project managers don’t find a room in their schedule to implement architectural recommendations. They probably have time, people and resources, but since they don't have a precise idea of the team's productivity, they feel afraid of accepting new non-functional requirements or changing existing ones. I've noticed that, in a chaotic environment, people become excessively pragmatic, averse to changes.

Architects expect that the organization adopts a more predictable and transparent software process. This way, it’s possible to visualize the impact of recommendations and negotiate when they are going to be implemented. They minimally expect a process that has iterations inspired on the classical PDCA (Plan, Do, Check and Act) cycle because it has loops with feedback, which are the foundation for continuous improvement.

The figure below depicts what could be considered as a pragmatic software process.

Iterations are overlapped in time in order to optimize people allocation, use of resources and guarantee the feedback from previous iterations. Each iteration is performed in a fixed period of time. This time depends on the context and it tends to fall as the organization gains more maturity. An iteration is composed of 4 phases (plan, do, check and act) and 5 events that may occur according to the planning. They are:

T1: It represents the beginning of the iteration, starting with its planning. The scope of the planning covers only the period of the current iteration. It should not be mixed with the general project planning, which is produced in one of the initial iterations to plan all other iterations. All members of the team participate in the planning.
T2: The execution of what was planned for the iteration starts. All members of the team must have something to do within the scope of the iteration. Nothing planned for future iterations should be done in the current iteration. People may produce all sort of output, such as documents, code, reports, meeting minutes, etc.
T3: Everything that is produced should be checked. Documents should be reviewed, code should be tested, user interfaces and integrations with other systems should be tested, etc. All found issues must be registered to be solved in due time.
T4: Solve all issues found during the check phase and release all planned deliverables. Everybody should deliver something. In case time is not enough to solve some found issues, they must be included in the planning of the next iteration with the highest priority. Statistics should be produced during this phase in order to compare the planning with the execution. The planning of the next iteration also starts at this point, taking advantage of the experience from the previous iteration.
T5: Once everything is released, the current iteration finishes. T2 of the next iteration immediately starts because most of people and resources are already available.

T1 to T5 repeats several times, in a fixed period of time, until the end of the project. This suggestion is process-agnostic, thus it can be implemented no matter what software process we claim to have in place or any other modern process we can think of.

In addition to the process, there are also some good practices:

Consider everything that describes how the system implements business needs as use cases. It can also be functional and nonfunctional requirements, user stories, scenarios, etc; but there must be only one sort of artefact to describe business needs.
Write use cases in a way that the text can be reused to: a) help business people to visualize how their needs will work; b) guide testers on the exploratory tests; and c) help the support team to prepare the user manual.
Avoid technical terms in use cases. If really needed, technical details may be documented in another artefact, such as use case realizations.
If needed, create use case realizations using UML models only. Representing use case realisations as documents implies on a huge overhead. Any necessary textual information can be added in the comments area of UML's elements.
Fix the size of use cases according to the effort to realize it. For example: we can fix that the maximum size of a use case is 1 week. If the estimation is higher than that, then the use case must be divided in two others. If the estimation is far lower than that, then the use case must be merged with another closely related use case. By simply counting the number of use cases we immediately know the effort and the resources required to execute the project. This fixed number is a parameter to compare the planning with the execution. By performing this comparison after every iteration, we gradually know how precise our estimations are becoming.
Use a wiki to document use cases and other required documentations, such as test cases, release notes, etc. Create a wiki page for each use case and use signs to indicate what is still pending to be released. The advantages of the wiki are: a) use cases are immediately available for all stakeholders as they are gathered; b) stakeholders can follow the evolution of the use cases by following updates in the page; c) it’s possible to know everyone who contributed to the use case and what exactly they did; and d) it’s possible to add comments to use cases, preserving all the discussion around it.
If the organization has business processes, which is another thing that architects also love, then put references in the business process' activities pointing to the use cases that implement them. A reference is a link to the page where the use case is published on the wiki.
Follow up use cases using an issue tracking system, such as Jira. Each use case must have a corresponding Jira ticket and every detail of the use case's planning, execution, checking and delivery must be registered in that ticket. The advantages of linking Jira tickets with use cases are: a) Jira tickets represent the execution of the planning and their figures can be compared with the planning, generating statistics on which managers can rely on; b) we know exactly every person who contributed to the use case, what they did, and for how long; and c) it’s an important source of lessons learned.
Test, test, test! It must be an obsessive compulsive behaviour. Nothing goes out without passing through the extensive test session.
Constantly train and provide all needed bibliography to the team on the technologies in use. The more technical knowledge we have inside of the team, the highest is our capability to solve problems and increase productivity.

Working this way, everything becomes quantifiable, predictable, comparable and traceable.

From the practices above we can extract the traceability flow from business to the lowest IT level, as depicted in the figure below.

Business process elements such as swimlanes and activities may inspire actors and use cases. Use cases and actors are documented on wiki pages. Each use case and actor has a page on the wiki, which has a unique URL and can be used to refer the element on email messages, documents, Jira tickets and so on. An Jira ticket is created for each use case and it contains a link to the use case's wiki page. This wiki page can also have a link to the ticket since it also has a unique URL. Jira tickets can be automatically linked the source code through the version control system (SVN) and declaratively linked to system's features and user interfaces. Since it's possible to create mock-ups in wiki pages, then we also link those wiki pages with user interfaces to compare the mock-ups with the final user interface. We finally have actors linked to security roles.

I admit that architects are not qualified to define and implement a software development process in the organization (they actually believe more in the Programming Motherfucker philosophy :D), but they are constantly willing to contribute to have one in place. As they have instruments to monitor servers, releases, tests, performance and so on, they also want project managers having instruments to estimate effort, predict events, anticipate problems and, therefore, produce better planning and results. Warning: Whatever we put in our software processes that is not quantifiable or measurable will become an expensive overhead.

Integrating Jira with Netbeans

2012-05-06T13:26:00.000+02:00

One of the advantages of hosting your open source project at Java.net is the availability of Jira to track your issues. Jira is one of the most popular issue tracking system available on the market, which drives tool developers to support it. This is the case of Netbeans, my working IDE, and also the case of Eclipse.

I recently configured my Netbeans to access Jug Manangement's issues. If you want to do the same, or with another project hosted on Java.net or even connect to the Jira available on your company's Intranet, then the following instructions may help you.

The first step is to install Jira plugin on Netbeans. In the menu, select Tools and then Plugins. Go to the tab Available Plugins and select JIRA. Follow the installation procedure and restart the IDE at the end. The figure below shows the plugin already installed. You may check as well if JIRA is in your list of Installed plugins to make sure everything went well.

In the view Services, where we connect to databases, webservers and others, we also find a new kind of service called Issue Trackers. By clicking with the right button on this service, you are about to create a connection to a issue tracker. A dialog like the following figure appears. Give any name to your connection, since this is not a predefined value. In case of Java.net, use the URL https://java.net/jira and the credentials you use to authenticate in the portal. Click on Validate to make sure that you input the values correctly and the connection with the server is working. Click on Ok to finish.

Now, you are connected but not ready to work yet. The next step is to find the issues. For that, click with the right button on the issue tracker that you just created and select the option Find Issues. It opens a new tab in the editor area where you are able to build your query as you usually do using Jira on a web browser. When you build the best query for your needs you can save it to constantly work with that. In the following figure I built a query that shows me all open issues of the project jug-management.

You can do something similar to your project and control your issues directly from the IDE. One of the main benefits of this approach is that, by restricting the use of the browser, we reduce the probability of losing the focus on the work due to other entertainment activities on the web such as news, social networks, chatting and so on.

Choosing Between Vaadin and JSF

2012-01-31T17:01:00.000+01:00

With the recent release of Primefaces 3.0, JSF finally reaches an unprecedent level of maturity and utility that puts it face to face with other popular Rich Internet Applications (RIA) options, such as Google Web Toolkit (GWT), ExtJS, Vaadin, Flex and others. This open source project also proved to be very active and in a constant growing path.

I have been working with JSF + Primefaces since October 2010, when I started developing the project JUG Management, a web application conceived to manage user groups or communities focused on a certain domain of knowledge, whose members are constantly sharing information and attending social and educational events. JSF is a standard Java framework for building user interfaces for web applications with well-established development patterns and built upon the experience of many preexisting Java Web development frameworks. It is component-based and server-side user interface rendering, sending to clients (web browsers) pre-processed web based content such as HTML, JavaScript and CSS. My experience on this technology is openly available on java.net.

Meanwhile, I had the opportunity to create a Proof of Concept (PoC) to compare JSF and Vaadin in order to help developers and architects to decide between one of them. Vaadin is a web application framework for RIA that offers robust server-side architecture, in contrast to other Javascript libraries and browser plugin-based solutions. The business logic runs on the server while a richer user interface, based on Google Web Toolkit (GWT), is fully rendered by the web browser, ensuring a fluent user experience.

The result of the PoC was surprisingly interesting :) It ended up proposing both technologies instead of eliminating one of them. I found out, exploring available books, articles, blogs and websites, that despite being able to implement all sorts of web applications, each technology has special characteristics, optimized to certain kinds of those applications. In practical terms, if we find out that JSF is better for a certain kind of application, that's because it would take more time and code to do the same with Vaadin. The inverse logic is also true. In order to understand that, we have to visit two fundamental concepts that have direct impact on web applications:

Context of Use considers the user who will operate the application, the environment where the user is inserted, and the device the user is interacting with.
Information Architecture considers the user of the application again, the business domain in which he or she works on and the content managed in that domain.

Notice in the figure bellow that the user is always the center of attention in both concepts. That's because we are evaluating two frameworks that have direct impact on the way users interact with web applications.

Visiting the concepts above we have:

Environment
Some applications are available for internal purpose only, such as the ones available on the intranet, other applications are used by external users, such as the company website.

Users of internal applications are more homogeneous and in limited number, which means that the UI can be a bit more complex to allow faster user interactions. That explains the fight Microsoft Office vs. Google Docs. The last one is not yet fully acceptable in the office environment because it has less functionalities than Microsoft Office. The latter is, on the other hand, more complex and more expensive. However, a limited number of users to a larger number of features makes acceptable to have some additional costs with training sessions to profit from the productivity features.

A company website targets heterogeneous users in unlimited environments. It is not possible to train all this people, thus simpler user interfaces with short and self-explanatory interactions are desirable.

Considering the environment, we would recommend Vaadin for homogeneous users in limited environments and JSF for heterogeneous users in unlimited environments.

Device
Different devices demand multiple sets of UI components, designed to look great from small to large screens. Fortunately, both frameworks have components to support the full range of screen sizes from regular desktops to mobile devices. The problem is that different devices bring different connectivity capabilities and the application should be ready to deal with short band-width and reduced transfer rates. In this case, Vaadin seems to be more suitable for multiple devices, as long as the variety of devices is not so extensive, because the user interface is rendered locally, using JavaScript, and it has a richer Ajax support to optimize the exchange of application data with the server.

Business Domain
In principle, good quality UI frameworks such as JSF and Vaadin can implement any business domain. The problem is how experienced the team is with the technology or how small is the learning curve to master it. Business is about timing and the technology that offers the best productivity will certainly win. If your team has previous experience with Swing then Vaadin is the natural choice. If the previous experience was more web-oriented, manipulating HTML, CSS ans Scripts, then JSF is recommended.

Content
Content is a very relevant criterion for choosing between Vaadin and JSF. In case the application needs to deal with volumous content of any type, such as long textual descriptions, videos, presentations, animations, graphics, charts and so on, then JSF is the recommended over Vaadin because JSF uses a web content rendering strategy to profit from all content-types supported by web browsers without the need for additional plugins or tags. The support for multiple content is only available on Vaadin through the use of plugins, which must be individually assessed before adoption.

User
Last, but not least, we have the user, who is the most important criterion when choosing a UI framework. We would emphasize two aspects:

The user population: the largest is the target population the highest are the concerns about application compatibility. It must deal with several versions and types of browsers, operating systems, computers with different memory capacity and monitor resolution. All these without failures or security issues. For larger populations, the most appropriate technology is the most compatible one in a cross-platform environment, which is the case of JSF, since it uses a balanced combination of HTML, JavaScript and CSS, while Vaadin relies only on JavaScript and CSS. But shorter populations would have better profit with Vaadin because cross-browser compatibility is and will remain being a very hard work to be done by Vaadin's development team behind the scene.
User's tasks: If the application is intensively operated by users then it is expected that it has more user's tasks implemented. On the other hand, if the application is rarely used or has short intervals of intensive use, then there is a lower concentration of user's tasks. According to the PoC, Vaadin is the technology that provides the best support on delivering user tasks with richer user interaction because of its fast visual response. JSF is less optimized on which concerns the user interaction.

In conclusion, instead of discarding one of these frameworks consider both on the shelf of the company's architectural choices, but visit the criteria above to make sure that you are using the right technology to implement the expected solution. A simple way to apply those criteria would be to assign weights to each criterion, according to the project's characteristics; set which technology is appropriate for each criterion; and sum the weights for each technology. The highest weight elects the technology to be used in the project.

Becoming Part of the Java Code Geek Community

2012-01-05T10:21:00.001+01:00

I'm glad to announce that I just became part of the Java Code Geeks (JCG) community! I have been following this community for a long time, consuming a lot of great Java articles, and now I'm part of it. This is a great honor and also a great responsibility because it is a way of pushing myself to write betters articles and do it in a more frequent way.

For those who don't know JCG, this is a community of bloggers whose articles are of interest to the Java developer community. They simplify the process of publishing selected blog articles by JCG members on a aggregator website. This is a win-win game because JCGs enjoy substantially increased visibility and the audience enjoys great content.
I also had the opportunity to include CEJUG as a supporting user group. In the coming days I will find time to integrate JCG's posts with CEJUG's website using rss and let people know how I did it here.

EJB Lookup in a Vaadin Application

2011-10-10T11:16:00.000+02:00

It has been a long time since the last Service Locator I have implemented. I thought it wouldn't be necessary anymore considering the maturity of the Java EE CDI (Contexts and Dependency Injection). My first implementation was to make use of EJBs in a Struts-based web application. After that, I started working with JSF, which only requires annotated attributes with @EJB or @Resource to communicate with the business layer. So far, it has been a great experience until they asked me to evaluate Vaadin as a front-end technology for business applications.

Before going too far, I have read the article "Adding JPA to the Address Book Demo", published on Vaadin's wiki, which explains how to call EJBs from Vaadin's classes to retrieve and persist data from the business layer. EJBs use JPA to get and put data in the database. They suggested to call EJBs from a custom servlet, which, according to the Java EE specification, has the ability to make EJB calls using CDI. If we have 1 or 3 EJBs to call, it seems to be an appropriate solution, but what to do in the Servlet when we have ~40 EJBs to deal with? How to pass all these references to Vaadin's application class? The interface of this class can go nuts! That's why I believe that the lookup using JNDI is desirable.

The following code is the Service Locator that I'm using in my Proof of Concept (PoC).

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class ClientServiceLocator {
   private Context initialContext;
   private Map cache;
   private static ClientServiceLocator
           ourInstance = new ClientServiceLocator();

   public static ClientServiceLocator getInstance() {
      return ourInstance;
   }

   private ClientServiceLocator() {
      try {
         this.initialContext = new InitialContext();
         this.cache = Collections.synchronizedMap(new HashMap());
     }
     catch(NamingException ne) {
         System.err.printf(
            "Error in CTX looking up %s because of %s while %s",
            ne.getRemainingName(),
            ne.getCause(),
            ne.getExplanation());
      }
   }

   public Object lookupEjb(String ejbName) {
      if(this.cache.containsKey(ejbName)) {
         return this.cache.get(ejbName);
      }
     else {
         try {
            Object ejbRef =
               initialContext.lookup("java:comp/env/"+ ejbName);
            this.cache.put(ejbName, ejbRef);
            return ejbRef;
         } catch (NamingException ne) {
            throw new RuntimeException(ne);
         } catch (Exception e) {
            throw new RuntimeException(e);
        }
      }
   }
}

The class MyServiceLocator follows the Singleton design pattern, making sure that there is only one instance of the object to serve all requests from the web application. The unique instance is created at the class' initialization process and since the constructor is private, the class cannot be instantiated by another class, being available only through the method getInstance(). The constructor initializes the context and creates a synchronized map where we store all references already created. The method lookupEjb(String ejbName) locates EJBs whose names are available in the local JNDI context. This method only works for those EJBs whose references are declared in the web.xml file, as listed below.

<web-app version="2.5"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemalocation="http://java.sun.com/xml/ns/javaee
        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

   <display-name>Information Systems</display-name>
   ...
   <ejb-local-ref>
      <ejb-ref-name>InformationSystemBean</ejb-ref-name>
      <ejb-ref-type>Session</ejb-ref-type>
      <local>
         example.business.InformationSystemBeanLocal
      </local>
      <ejb-link>
         eac-architecture-ejb.jar#InformationSystemBean
      </ejb-link>
   </ejb-local-ref>
</web-app>

The tag <ejb-local-ref> is used to declare a reference to a local EJB. The example above maps only one EJB. So, you have to repeat it for each EJB you want to map. Details about this tag can be found here. Once declared, we can get an instance of the EJB in any part of the application using the following code:

private InformationSystemLocal informationSystemBsn =
   (InformationSystemLocal)MyServiceLocator.getInstance()
                              .lookupEjb("InformationSystemBean");

The variable is typed with the EJB local interface, which is InformationSystemLocal. The service locator returns an instance of the EJB named as InformationSystemBean, which is by default the EJB's implementation class. Notice that none of the code above is necessary when we use CDI. The invocation of AjudaBsn would be simply like that:

@EJB
private InformationSystemLocal informationSystemBsn;

CDI is good and elegant, but not widely applicable. The way it is implemented today is the main weakness of the Java EE specification. Maybe there is some strong reason why EJB's annotations don't work in every Java class. I simply don't see this misterious reason because Spring has addressed this issue since long time ago simply using aspect orientation.

My Favorite Steve Jobs' Lesson

2011-10-08T11:19:00.000+02:00

"Your time is limited, so don’t waste it living someone else’s life. Don’t be trapped by dogma — which is living with the results of other people’s thinking. Don’t let the noise of others’ opinions drown out your own inner voice. And most important, have the courage to follow your heart and intuition. They somehow already know what you truly want to become. Everything else is secondary" - Steve Jobs (1955 - 2011)

R.I.P. Steve Jobs.

Some Interview Questions to Hire a Java EE Developer

2011-09-26T12:24:00.000+02:00

The Internet is full of interview questions for Java developers. The main problem of those questions is that they only prove that the candidate has a good memory, remmembering all that syntax, structures, constants, etc. There is not real evaluation of his/her logical reasoning.

I'm listing bellow some examples of interview questions that check the knowledge of the candidate based on his/her experience. The questions were formulated to verify whether the candidate is capable of fulfilling the role of a Java enterprise applications developer. I'm also putting the anwsers in case anybody want to discuss the questions.

1. Can you give some examples of improvements in the Java EE5/6 specification in comparison to the J2EE specification?

The new specification favours convention over configuration and introduces annotations to replace the use of XML for configuration. Inheritance is not used to define components anymore. They are defined, instead, as POJOs. To empower those POJOs with enterprise features, dependency injection was put in place, simplifying the use of EJBs. The persistence layer was fully replaced by the Java Persistence API (JPA).

2. Considering two enterprise systems developed in different platforms, which good options do you propose to exchange data between them?

We can see as potential options nowadays the use of web services and message queues, depending on the scenario. For example: when a system needs to send data, as soon as they are available, to another system or make data available for several systems, then a message queuing system is recommended. When a system has data to be processed by another system and needs back the result of this processing synchronously, then web service is the most indicated option.

3. What do you suggest to implement asynchronous code in Java EE?

There are several options: one can post messages to a queue to be consumed by a Message-Driven Bean (MDB); or annotate a method with @Timer to define the time to execute the code programmatically; or annotate a method with @Scheduler to define the time to execute the code declaratively.

4. Can you illustrate the use of Stateless Session Bean, Statefull Session Bean and Singleton Session Bean?

Stateless Session Beans are used when there is no need to preserve the state of objects between several business transactions. Every transaction has its own instances and instances of components can be retrieved from pools of objects. It is recommended for most cases, when several operations are performed within a transaction to keep the database consistency.

Statefull Session Beans are used when there is the need to preserve the state of objects between business transactions. Every instance of the component has its own objects. These objects are modified by different transactions and they are discarded after reaching a predefined time of inactivity. They can be used to cache those data with intensive use, such as reference data and long record sets for pagination, in order to reduce the volume of IO operations with the database.

A singleton session bean is instantiated once per application and exists for the lifecycle of the application. Singleton session beans are designed for circumstances in which a single enterprise bean instance is shared across and concurrently accessed by clients. They maintain their state between client invocations, which requires a careful implementation to avoid conflicts when accessed concurrently. This kind of component can be used, for example, to initialize the application at its start-up and share a specific object across the application.

5. What is the difference between queue and topic in a message queuing system?

In a queue there is only one producer of messages and only one consumer of these messages (1 – 1). In a topic there is a publisher of messages and several subscribers that will receive those messages (1 - N).

6. Which strategies do you consider to import and export XML content?

If the XML document is formally defined in a schema, we can use JAXB to serialize and deserialize objects into/from XML according to the schema. If the XML document does not have a schema, then there are two situations: 1) when the whole XML content should be consider: In this case, serial access to the whole document is recommended using SAX, or accessed randomly using DOM; 2) when only parts of the XML content should be considered, than XPath can be used or StAX in case operations should be executed immediately after each desired part is found in the document.

7. Can you list some differences between a relational model and an object model?

An object model can be mapped to a relational model, but there are some differences that should be taken into consideration. In the relational model a foreign key has the same type of the target's primary key, but in the object model and attribute points to the entire related object. In the object model it is possible to have N-N relationships while in the relational model an intermediary entity is needed. There is no support for inheritance, interface, and polymorphism in the relational model.

8. What is the difference between XML Schema, XSLT, WSDL and SOAP?

A XML Schema describes the structure of an XML document and it is used to validate these documents. WSDL (Web Service Definition Language) describes the interface of SOAP-based web services. It can refer to XML schemas to define existing complex types passed by parameter or returned to the caller. SOAP (Simple Object Access Protocol) is the format of the message used to exchange data in a web service call. XSLT (eXtensible Stylesheet Language Transformation) is used to transform XML documents into other document formats.

9. How would you configure an environment to maximize productivity of a development team?

Every developer should have a personal environment capable of executing the whole application in his/her local workstation. The project should be synchronized between developers using a version control system. Integration routines must be executed periodically in order to verify the compatibility and communication between all components of the system. Unit and integration tests must be executed frequently.
---

You can increment this set of questions covering other subjects like unit testing, dependence injection, version control and so on. Try to formulate the questions in a way that you don't get a single answer, but a short analysis from the candidate. People can easily find answers on the Internet, but good analysis can be provided only with accumulated experience.

Development Environment to Work with WebLogic

2011-09-24T18:15:00.001+02:00

I have to confess that, despite not evolving as fast as the Java EE specification, Oracle WebLogic is a f*** good application server. Its stability is impressive and works smoothly with popular IDEs, such as Eclipse and Netbeans. Of course its qualities come with a cost, which is expensive for poor developers like us, but it's worthwhile for companies.

The official name of WebLogic is "Oracle WebLogic Server 11g Standard Edition". It is part of a broader range of products called "Oracle Fusion Middleware", which offers a complete support for enterprise service-oriented applications (SOA). I'm currently working with WebLogic 10.3.4, which is the first version that supports JSF 2.0, my favority web framework. WebLogic is available for download on Oracle's website. Go to the download page to get your copy. To install it:

Unzip the file in your development folder. For example /home/you/java/weblogic.
Create the environment variable JAVA_HOME, pointing to your JDK installation.
Create the environment variable MW_HOME pointing to /home/you/java/weblogic.
Go to the command line and run the installation configuration script $MW_HOME/configure.[sh/cmd].
Create the domain to start working with WebLogic, running the command MW_HOME/wlserver/common/bin/config.[sh/cmd] and following the instructions on the screen.
Start a web browser and open the url http://localhost:7001/console to access the administration console.

Now, we have to configure the IDE to start, debug, and stop WebLogic, as well as deploy Java EE applications. Because most developers actually use Eclipse as a working IDE, let's configure it, installing the necessary plugin. I'm using Oracle Enterprise Pack for Eclipse (OEPE), a plugin that empowers Eclipse to develop Enterprise Java Application for Oracle Products. To install it:

Open Eclipse and go to the menu Help - Install New Software...
Add a new repository by clicking on Add...
Inform the name Oracle Enterprise Pack for Eclipse and the URL http://download.oracle.com/otn_software/oepe/indigo if you are using Eclipse Indigo, or http://download.oracle.com/otn_software/oepe/helios if you are still using Eclipse Helios.
Follow the instructions and restart Eclipse to finalize.

Finally, configure the plugin to integrate the IDE with Eclipse:

Go to the menu Windows - Show View and select Servers.
Click with the right button of the mouse on the working area of the view and select New - Server.
In the list of server types, go to the category Oracle and select Oracle WebLogic Server 11gR1 (10.3.4), or the version of WebLogic that you have installed. It's important to select the right version, otherwise an error will continously occur.
Make sure that the field Server's host name contains the value localhost and press Next.
In the field WebLogic home inform the path /home/you/java/weblogic/wlserver.
In the field Java home inform the path to your JDK installation.
You can optionally install some server extensions. I recommend to install all available extensions, clicking on Install, besides each item. Press Next to continue.
Leave the option Local selected in the Server type field and inform the location of the domain. The domain was created in the first part of this tutorial, when we executed the configuration assistent.
Press Finish to conclude.

That's it! Make sure to select this server when creating a new Java EE application. Don't hesitate to share your experience while following this tutorial.

Creative Solution to Keep Business Running Under Special Circumstances

2011-08-21T11:32:00.008+02:00

Rue du Luxembourg, Brussels, around 7:20 in the morning, going to work. A drugstore was under complete renovation. It wouldn't be open for customers... unless they put the drugstore in a special container and place it on the sidewalk just in front of it :)

If you are planning to renew your business, take some time to think about a creative solution to keep it running.

Real Social Values that We Can't Find on Facebook

2011-08-20T12:55:00.011+02:00

Every working day, my wife and I go walking from home to the train station very early in the morning. Sometime ago, there was a singular thing on the way that caught our attention: a litle "burnt yellow" pumpkim was beautifully growing in the garden of a house in the neighborhood. Over the next 3 months we patiently followed the growth of that pumpkim, which was slowly becoming gorgeous.

Day after day, the temptation to take that away was inevitably increasing. However, the romantism of that rare scene of mutual trust between the residents and passersby was bucolically charming, surrounded by a scenario of a calm small town on the countryside of Belgium.

When the pumpkim was finally looking ripe, the residents put a lovely message for those of us who resisted to that daily temptation.

The message translated from French was:

"Our pumpkim is ready to be eaten.... Thanks to all people who gave a benevolent look and resisted the temptation to take it. So, come and enjoy a good pumpkim soup among neighbors this Friday, August 19th, from 7 p.m.! Everyone is welcome."

That's a great example of social interaction that is rare to see nowadays. It comforts me, makes me believe that real social interaction is far more valuable for life than the digital ones, like Facebook and Google+.

I'm Pregnant!

2011-07-06T18:35:00.000+02:00

Today, my wife gave me the greatest news I've ever received. She said that I'm gonna be a DAD! Uhuu! \o/ This is something very powerful, you know?! I have no words to describe my expectation to become a father. The news has an immediate impact on the way we see life from now on. All plans we made for ourselves in the coming days, months, years, are now totally forgotten. This new life has the power of attracting all our attention and dedication, which makes me think that the future cannot be designed, at least for the next nine months, and everything that will happen is unpredictable and deserves immediate response.

You may wonder why the title is "I'm pregnant" if I'm obviously a man. It is because I'm feeling all symptoms of a pregnancy that my wife is going through. Of course my Love is reading lots of books, websites and magazines about her new experience. As she tells me what she is feeling, I get myself feeling the same! :D hehehe Nausea, fatigue, headaches, frequent urination, and everything else she tells me. I'm also following the same diet and habits. The absence of coffee is the worse part. I was used to drink 3 to 4 cups a day, which makes me realize now that I was addicted to it. I'm probably getting some weight too, but I certainly need self control about food because one big belly is enough for a pregnant couple.

By the way, a baby is not the only good news. The package also includes 9 months (maybe more) without premenstrual irritation, menstruation, birth control, tampons, and no worries about keeping a flat tummy ;-)

This boy or girl will probably have some time in the future to visit this post. So, I'm getting the opportunity to say a few words:

"We will do our best to educate you the most constructive and positive way possible. It includes doing things that you won't like at the moment you experience it, but you will understand when you grow up. You have to understand that you are our first experience as parents and we will probably make some mistakes in the course of your education. We never know.

We plan to have another baby, maybe a third one also, because we believe that it's important for you to have a brother or sister. When we are all growing together as a family, don't worry when you notice that we are giving more attention for them than for you. This is because they are younger and naturally deserve more attention, as you received when you were at the same age. We also understand that you are more mature to understand that. At some point none of you will have privileges any more and we will treat you all equally, as we love you all equally.

Another point is concerning the language we speak with you. At home you will listen to Portuguese. At the day care center you will listen to French. Furthermore, since you were born in Belgium, which has three official languages, the language confusion will get even worse :D. But it is good for you. We decided to speak in Portuguese with you because we think you should speak fluently with other members of the family, like your grandparents, uncles, cousins, aunts and so on. They are really nice people and they were all waiting for you too. I wished you could see their faces when your mother told them you were coming.

By the way, your mother is feeling great now! She is reading a lot of books that try to explain how to take care of you. We know they are not always right and the real thing will start when you show up here :) God! You have no idea how life already changed so far. Good changes of course. We have nothing to complain about. Just waiting for you now."

JUG Management Now on Git

2011-01-27T22:32:00.000+01:00

The JUG community asked and we have moved the JUG Management source code from SVN to Git. I have to admit that I'm new in Git and it seems to be a quite change of paradigm from SVN. My first feeling is that it is more complex. For the moment, my motivation to learn Git comes from the fact that there is a big probability that the market will value this knowledge.

To access the Java.net Git repository is not a trivial task :( You will need SSH (Security Shell protocol) to have an encrypted connection to the server. I think this is too much for our needs, since this is not such a critical system, but this is real life, thus I followed the steps below:

Download and install a Git client according to your operating system. Clients are available at http://git-scm.com/download.
Installing Git is not enough to start working. You have to configure it, adding a public SSH key to your site profile as described in Generating an SSH Key. The whole process will take some time, but if you do it carefully, step by step, everything will work fine. It worked in my first attempt ;-)
register yourself in CEJUG's project at java.net. You will have access to the repository only if you are a member of the project. Registering in the project doesn't mean you will become a CEJUG member. Actually, we use JUG Management to control our members ;-)
When you login on Java.net and go to the source code section, you will be able to see the checkout URI of JUG Management's repository. The address contains your username. Example: ssh://[user-name]@git.java.net/cejug~jug-management.
Copy the URI above and go to the command line and type the following command to checkout the code: git clone ssh://[user-name]@git.java.net/cejug~jug-management. It will create a folder "cejug-jug-management" in the directory you ran the command and the full source code will be available there.

This is a good start. Now you can open the source code and try to learn the project. I will explore in the next post how to open the source code in an IDE and build a package for deployment. At the same time, I'm learning how configuration management works with Git in order to start receiving your contributions. I'm studying the book Version Control With Git by Jon Loeliger for this. I hope the idea of branch is still there, just with a different name.

New CEJUG Open Source Project

2011-01-02T12:29:00.002+01:00

As I have mentioned yesterday, I'm working on a new project, managed by the CEJUG community, which aims to develop a web application for managing Java User Groups. We put it into production in the first day of the decade, January 1st, 2011, and we made the source code freely available on our java.net project.

The first goal we want to achieve is the definition of what is actually being a CEJUG member. Nowadays, we simply consider all those registered in our technical mailing as members. This simplicity is good for management purposes, but we lose lots of information because of that. We don't know, for instance, for what reasons a member is leaving the group. Did we do something wrong? What can we do to get better and get members back into the boat? We also noticed that even non-technical people, as entrepreneurs, recruiters, and those who decided to unsubscribe because of too many messages, would like to keep in touch with the group, not necessarily going into technical discussions, but proposing other ways to help. Adopting a separate application to manage subscriptions would help us to collect more feedback and be more inclusive.

Developing our own solution can make data work in our favour and allow our sustained growth. Consequently, we are generating an additional source of knowledge for the community. This application is open source and everyone can run and see how CEJUG works. Beginners will have a solid source to start their studies on the development of Java web applications, experts can help with bug fixing, refactoring, and developing new features according to our issue tracking. Adopted design patterns may be subject of valuable and warming discussions in our community.

Of course the application was developed in Java ;-) We have the duty to write the software architecture document in the coming days, but we can already say in advance what we are using to develop and deploy the application. The presentation layer was developed in JSF 2.0, using the Primefaces component library; the business layer was implemented in EJB 3.1; the persistence layer was implemented in JPA 2.0; data is persisted in MySQL; and everything is running on Glassfish 3.0.1 Application Server. The current version was developed using Netbeans 6.9 due to its productivity when developing JEE applications. We rely on the container to manage security, database transactions, connection pools, and email sessions.

The next step is to document the application, add customisable features and internationalise it in order to spread its adoption by several other JUGs out there. We are looking for contributors and supporters to make this a successful open source project. We hope one day, we could promote interoperability between JUGs through this application, sharing mutual knowledge, events, effort on the growth of the Java platform and the Java community.