How a JUG is Born and Stays Active Over the Years

(This post was originally published at yougi.org)

We recently attended EMEA IOUC Summit 2013 in Ghent, Belgium, last spring (EMEA IOUC stands for International Oracle User Group Community from Europe, Middle East and Africa). This meeting was very important because that's an opportunity that user group leaders have to share what really works and what actually doesn't work when managing their community.



After acquiring Sun Microsystems, Oracle included Java™ User Groups (JUGs) in IOUC and many JUGs within EMEA were invited to attend the summit. According to some veterans, the gathering at the beginning was like water and oil. Now, they're much more in line, but there is still a rich diversity in terms of organisation and culture. That's a real cultural mix.

JUGs are used to be independent and lean. They are supported not only by Oracle, but also by several players, such as RedHat, IBM, Google and others. They are less attached to products and more attached to solutions, which is inherited from the spirit of Java™: "Write once, run anywhere". Oracle does respect that, continuing as the main JUG supporter out there and avoiding interfering in JUG's organisation. The coordination of community initiatives is always done with JUG leaders, who contribute with ideas and actions through their respective user groups.

Recently, Oracle and community leaders realised that the process of creating new JUGs was outdated. Ironically, the process was heavy and difficult to manage, not fitting in Jug's philosophy. Perhaps, it explains why it didn't really worked. Bruno Souza, an active Java evangelist, was involved since the beginning and gave further details about that:

"Java.net was always structured to be a 'code' site, and because of that, it has the concept of project approval and the incubator. Project approval was the step where an admin of a java.net community would consider relating a project to their community (for example, the Desktop community would probably not accept a server side, JEE project). A JUG's project approval was very loose. If someone said their project was a JUG, we simply took their word for it. The project then would be accepted into the 'incubator', that was a staging area, were the project could start, and be clearly labeled as 'incubating'. To graduate from the incubator, we had a series of steps, that have evolved over time to include the JUGs Map and other basic requirements."

He concluded saying:

"Of course, as time went by, some of this got lost, some of the approval process started to be done by java.net support staff and not by the JUG leaders, many JUGs never completed the incubator steps (we have around 40 JUGs on the incubator right now), and many JUGs don't even know about any of that."

Then Oracle started a discussion with some community leaders (Bruno Souza, John Yeary, Nichole Scott, Tonya Moore, Sonya Barry and Frank Nikola) about what is working and what is not working. They came out with the following process to create and maintain JUGs:

1. A prospective JUG leader joins Java.net and requests a project with the proposed JUG name.
2. At creation, the project owner receives an automated email asking him(er) to contact the community manager at Java.net to request that the new JUG project be made public.
3. The JUG leader can choose between Java.net, their own hosting provider, a social network or any other online service to host JUG's online content. In case it is hosted elsewhere, the leader just have to add the external link in its Java.net project profile. Actually, the only reason Java.net has to create an actual project is to prevent name collisions and keep the database consistent. The project itself can be entirely empty.
4. Java.net asks for a KML file to add the location of the JUG in the map, in case it hasn't been supplied yet.
5. Java.net's team adds the JUG to the map and make the JUG's project public, moving it directly to the main JUG community.

Paired with this, Java.net will start an annual review of JUGs. The process works this way:

1. Once a year, people listed as "admin" in JUGs' projects receive an email asking if they're still active and if Java.net needs to update any information on the site. The reply can be as simple as "yes, we're still active, no changes".
   
2. If Java.net doesn't receive a positive reply within 30 days, they will follow up with a bit of a research to see if they can find the JUG in question. Perhaps the leadership has changed or a URL has been updated.
   
3. Java.net tries a second contact using any new information they have. If necessary, they translate the message to the local language.
   
4. If Java.net doesn't receive a response to the second inquiry within 30 days, then they send the final notice.
   
5. At 90 days without a reply, Java.net moves the JUG project to an archive/inactive state and removes the marker from the map.
   
6. A quick note is sent to the leaders' list, letting them know which JUG has been retired.
   

Any retired JUG can be reactivated at any time, by going though the first process described above.

The intention, as pointed out by Mattias Karlsson, JFokus organiser, is to be "generous and don't set boundaries if anyone wants to start a JUG.". Sonya Barry, director of community Infrastructure at Oracle, believes the goal is "to grow the community, and make it easier to join and more inclusive".

These processes started running in March 2013, too soon to figure out what is coming out of them. They invite further discussions a year from now to see how effective they are. But it is already good news to have established and transparent procedures. Congratulations for the team involved!

Statistics Help JUGs Make Good Decisions

(This post was originally published at yougi.org)

Since its first execution, in January 2011, Yougi has been helping CEJUG to manage its membership process and events. Yougi has collected a lot of valuable data in the last 2.5 years and it is urging now to explore all possibilities of data analysis. Some relevant analysis have been done and we aim to discuss them now.

The figure below depicts two charts generated by Yougi to show the membership growth during the current year while comparing it with the previous year. The intention of the chart is not to show the total number of members, but the growth throughout the year, taking into consideration only data collected in that period.



By comparing real events with these charts CEJUG could understand what was actually happening and make decisions based on that. At the beginning of 2012 the group was very active, with many events and participation. However, activities felt down throughout the year after a crises in the leadership team. It impacted the group's attractiveness reducing the number of new members. At the beginning of 2013, CEJUG went through a major leadership change and general reorganisation, resulting in concrete growth in the latests months of 2013.

Thanks to the latest events and projects supported by CEJUG, the group is on pace to surpass the year 2012 in number of registrations. The last three months have been higher than last year's results for the same period. If this pattern of growth persists in the next six months, CEJUG will have a lot to celebrate at the end of 2013.

Data shows that events are what really makes the difference, because it was exactly during the months of April, June and May that events took place in 2013. The same phenomenon can be observed in 2012, where major events were held in February, March and May.

With time, it gets harder to overcome previous years because there is a limited amount of programmers in the region covered by CEJUG. But there is always a lot of factors that may ensure continued growth. We are going to list three:

• Market growth: When the IT market grows, it attracts more professionals and some of these professionals are Java developers. To attract these people, CEJUG can organize events within companies.
• New Students in Computer Science: Every year, hundreds of young people choose computer science as their future carrier. CEJUG already collaborates a lot with local universities, although this collaboration can be further enhanced.
• Nationalisation of the group: CEJUG already has a considerable number of non-local members, showing that it has a good level of attractiveness. Therefore, CEJUG has potential to become a national community, representing Brazil in several international initiatives.

These factors could help to organize CEJUG's actions to ensure good results in 2014.

Speaking at Brussels JUG: User Experience for Business Process Applications

I'm glad to inform that I will speak at the next Brussels JUG's event about user experience thinking and design for business process applications. The event will take place at Hogeschool-Universiteit Brussel, Building Hermes, on Thursday, 30th of May, at 6:30 pm. Visit Brussels JUG website for more information: http://www.brussels-jug.be.

You won't find a lot of information about this subject on this blog, but I have been doing research about it in parallel since 2006, in collaboration with Kênia Sousa, who would be happy to share the stage, but she had to decline due to family duties. You may find more information on the page Publications of this blog.

If you were assigned to design and implement a business process based application, You may find this session interesting. User interface design is the most time consuming task in a software development process. It is highly subjective and under heavy criticism by end-users. This presentation will help you better deal with this problem, exploring strategies to represent business processes in a way that end-users can easily understand what they see based on their business knowledge. We will discuss about a different approach for Business-IT traceability based on UX, an architecture and a methodology to support constant process changes, navigation approaches and the right widgets for the right actions.

See you there!

Getting Rid of Blurred Netbeans in Your Macbook Pro Retina Display

If you have a MacBook Pro retina display you are probably wondering why your Java desktop applications look so blurred. That's because applications should be adapted to look great on the new retina display technology. Native Mac OS applications are automatically adapted by the operating system, but Java applications are rendered by the JVM instead, which has to be adapted to the new technology.

The good news is that Apple already adapted the JavaSE 6 version they distribute to the retina display technology. So, any desktop application running on top of that JVM will look good. The bad news is that JavaSE 6 is old, pretty old, JavaSE 7 has been around for a while and Apple didn't adapt it yet. It's true that Apple is involved on the OpenJDK project, but nobody knows whether adapting it to Retina Display is something proprietary or not. The feeling we have it that Apple doesn't really care about it. That's a shame.

We, programmers, are impacted because we use Java-based IDEs to develop our Java Apps. I particulary use Netbeans and it does has problems with Retina Display. If you are lucky, Netbeans will detect JavaSE 6 during the installation and configure itself to use it. But, if you have JavaSE 7 installed, Netbeans will probably favor it and the interface will become blurred. Fortunately, Netbeans can be configured to run on top of JavaSE 6 and, at the same time, use JavaSE 7 separately to run our apps. Unfortunately, we have to do it manually.

To proceed:

1. go to /Applications/NetBeans/, click on the file Netbeans 7.3, open its context menu and select the option "Show Package Contents".
2. In the package, navigate to /Contents/Resources/NetBeans/etc and edit the file netbeans.conf.
3. Uncomment the variable netbeans_jdkhome and set its value like that:
   netbeans_jdkhome="/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home".

That's it! It will change the default JDK used by Netbeans. Start it again to see the result.

A possible colateral effect of this change is the exception "Unsupported major.minor version 51.0" when you compile your project targeting JavaSE 7, but the corresponding JDK is not available yet in the IDE. To fix that:

1. go to the menu Tools / Java Platforms to see a dialog as shown in the figure below.
2. add other JDKs you have installed. My JDK 1.7, for instance, is located at: /Library/Java/JavaVirtualMachines/jdk1.7.0_##.jdk/Contents/Home. Yours is probably somewhere there too.

Try to run your projects again to get rid of the exception.



It worked for me. I hope it works for you too. :)

Look At It Carefully And You Will Find Something To Improve

(This text was originally published at RebelLabs' Website.)

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!