Knowledge Is Everything

JEEConf - Kiev, 2012 - Report

2012-05-20T15:15:00.001+02:00

This year we had the second JEEConf. The amount of stages was increased from three to four stages.
I was really impressed about conference program "notebooks" :-) it was well done. The amount of people was really huge more then 600. I think it's impressive number for the second conference.

As usual I've selected the most interest topics to watch/visit to:

1. Play with Play! by Anton Naumov
The presenter briefly has shown the Play Framework v.1.2.x features and discussed the pros&cons. The most notably was that he stated the "fails" caused by this framework and how we can avoid similar stuff. The most loud message was "use Spring/MVC, Hibernate and Maven" if you are experienced with them :-). And try to use Play for prototype projects.

2. Hibernate performance tuning by Sander Mak
It's very interesting and pragmatic topic. Even more I can say this presentation was a bunch of receipts for Hibernate performance improvement. There were depicted very interesting nuances which will be definitely valuable in real life codding.I'm looking forward for slides.

3. Methodology of performance optimization by Alexey Shipilyov and Sergey Kuksenko
It was the most low-level topic on this conference. Guys shown the different ways to perform the subject. They review and in pair-speech way very complicated issues in performance optimization from conceptual point of view. I can't say that I will be able to reuse everything from this speech, but it's great start point for me. They are very proficient presenters.

4. Becoming a Professional Java Developer by Yakov Fain
I must say "Thank you" for this speech. It was cool. Yakov has highlighted the non-technical aspect of Professional (Java) Developer. Of course his advices and observation are based on own experience and might be biased for somebody. But it's honest and reasonable speech might open "some" boring minds. Also, Yakov recommended to read his free e-book "Enterprise Software without the BS". I've already downloaded it and I'm planning to read it in nearest weeks.

5. Inject Injection by Yuriy Litvinenko
It was like a case study report about involving DI Framework (in this case Google Guice) in legacy project. It was very interesting, because I believe it's challenging task. The presenter has highlighted the issues which his team faced with. I can say this experience might be valuable when somebody needs to decide the benefits and evaluate the risks of involving DI Framework in something "really old". Well done.

6. Cloud Java platforms: what's inside and what's the difference by Ruslan Synytskyy
It was a pleasure to see ukrainian who is one of the founders of Jelastic. Ruslan has reviewed different types of "* as a Service": SaaS, PaaS and IaaS. The comparison criteria of PaaS's are very useful for further evaluation.

7. Why do I hate the Hibernate? by Mikalai Alimenkou
It was pragmatic, based on real experience presentation with tons of Hibernate issues. It's very useful for anyone who's developing application with Hibernate. We must know the weaknesses of our tools. Mikalai has used very interesting approach to blame something/someone: "nasty granny". You should review the slides to this presentation to understand what does it mean.

I'd like to say "Thank you" JEEConf organizers team. You are doing very important work for Ukrainian Java Community.

See: JEEConf - Kiev, 2011 - Report

Review: Java Brains Spring Framework - Core Spring, by Koushik Kothagal

2012-05-02T17:35:00.002+02:00

I've recently watched the subject Java Brains - Spring Framework video tutorials and I must admit that these screencasts were well done. One of the best Java related video tutorials I've ever seen. Whether you are experienced or beginner developer it worth to watch them all. It's very good sample how to produce qualitative and pleasure to watch screencasts.

Let's review each tutorial one-by-one just to have some snapshot what was described there:

01 - Understanding Dependency Injection Dependency Injection (DI) introduction. Here was explained why do we need DI and some conceptual sample.

02 - Setting Up Project Setup. The author avoided using any build tools (Ant, Maven) and set up Eclipse-based project via using Eclipse User Library.

03 - Understanding Spring Bean Factory Explained the differences between Factory pattern and Spring Bean Factory without any technical details, plain conceptual overview.

04 - Writing Code Using the Bean Factory Actually it's the first video with some code inside. Author use classical approach to introduce Spring DI in practice - wrote simple code without Spring and re-wrote it with Spring. And it has nice effect - it became very descriptive.
The next Spring-related things were introduced:

spring.xml
BeanFactory
XmlBeanFactory and FileSystemResources
bean instantiation via factory

05 - ApplicationContext and Property Initialization Replaced BeanFactory with ApplicationContext. How to initialize bean property via spring.xml has been shown.

06 - Using Constructor Injection Depicted different ways of constructor injection:

plain
index based
type based

07 - Injecting Objects Created simple object and shown how to inject object dependency (i.e. was used "property" tag and "ref" attribute, <property name="propname" ref="beanref" />

08 - Inner Beans, Aliases and idref The topic has pretty descriptive content, nothing more was here.

09 - Initializing Collections Here List was used as sample to initialize bean with collection. Stated that the same approach should be applied to Set and Map.

10 - Bean Autowiring Configured autowiring via spring.xml. Described pros&cons:

byName
byType
constructor

11 - Understanding Bean Scopes Explained bean scopes:

Singleton
Prototype
Request
Session
Global Session

12 - Using ApplicationContextAware Nicely shown how to use ApplicationAwareContext and BeanNameAware interfaces.

13 - Bean Definition Inheritance Nice Spring feature is bean definition inheritance and how it is different from OOP inheritance. Explained when to use it and what is the benefits. Introduced bean abstract and parent attributes and when to use it.

14 - Lifecycle Callbacks Introduced init and destroy methods in different incarnations:

InitializingBean and DisposableBean interfaces
bean tag attributes: init-method and destroy-method
beans tag attributes: default-init-method and default-destroy-method
Added AbstractApplicationCantext to switch on redisterShutdownHook()

15 - Writing a BeanPostProcessor Shown how to implement custom BeanPostProcessor

16 - Writing a BeanFactoryPostProcessor Shown how to implement:

custom BeanFactoryPostProcessor
introduces properties for spring.xml via adding PropertyPlaceholderConfigurer (implementation of BeanFactoryPostProcessor)

Explained when and why to use BeanFactoryPostProcessors. Explained the differences between BeanFactoryPostProcessors and BeanPostProcessor.

17 - Coding To Interfaces Rewritten the initial demo project to support interface based design, the right way for developing Spring applications :-)

18 - Introduction to Annotations and the Required Annotation Added @Required annotation in demo project and activated it via adding bean post processor RequiredAnnotationBeanPostProcessor.

19 - The Autowired Annotation Shown how to use:

@Autowire and @Qualifier annotations
<context:annotation-config /> in spring.xml

20 - Some JSR-250 Annotations Shown how to use:

@Resource annotation
@Resource annotation with parameters
@PostConstruct annotation
@PreDestroy annotation

21 - Component and Stereotype Annotations Added the <context:component-scan base-packaeg="package" /> to spring.xml. Shown how to use @Component annotation and what rules applied to this annotation. Also, were mentioned other Spring stereotypes.

22 - Using MessageSource To Get Text From Property Files Shown how to use ResourceBundleMessageSource to get properties.

23 - Event Handling in Spring Very nice introduction tutorial into the subject: even definition, event listeners and even publishing on application level.

Ofcource, these tutorial are only intro and you should read Spring Documentation to gain the Spring "black" magic. But, it's good start point.

Review: Getting Good with Git by Andrew Burgess

2012-04-24T19:15:00.000+02:00

There are several books about Git. I've decided to review them all and started with "Getting Good with Git" by Andrew Burgess

First of all it's beginner level book. I wouldn't recommend it to anyone experienced developer. Even more it's more like tutorial and not a book.
So, based on previous statements the next chapters can be easily cut off:

Introduction to Git
Commands
GitHub

IMHO, I would left the next two chapters:

Configuration
Beyond the Basics

And more important is the price of this book: $19. Guys, come on $19 for this. It doesn't cost this money.

Summary: don't spend your time and money on this book.

Why you should join a user group?

2012-03-27T00:09:00.002+02:00

Here I'd like to highlight the most important benefits for me:

Networking - ability to make social connections with developers from other companies
Learning - it's the right place to learn something for free and improve you skills.
Knowledge sharing - you shouldn't always take also you can give something to others. In our case it's your knowledge. Most people are very kind and really like to share own experience.
Public Visibility - here you can promote yourself as passionate and well skilled developer
Job Opportunities - you can find new contact which suggest a new job
Find Expert - it's the right place to find the right people which might help you to solve some technical problems
Become an Expert - it can happen
Meet Nice People - just fact :)

If you have other nice benefits please add in comments.

Java Related Free Video Trainings

2012-03-15T13:30:00.001+02:00

I've decided to collect Java related video tutorials and screencasts. Here is the initial list:

State of numerical computation languages

2012-02-26T20:19:00.000+02:00

When I was a student I spent a huge amount of time doing difference numerical computation with MATLAB and Maple. I must say I was falling in love with MATLAB. This environment, language and visualization possibilities were amazing and very powerful. I simply couldn't choose another stuff. It gave me a chance fully concentrate on engineering problems I had been trying to solve.

But now I must admit that MATLAB is very expensive software. And we should look around for other open-source mathematical computation environments. Today I'm biased because I prefer to invest time in general purpose language then in specialized computation languages (like MATLAB, R).

I've found very interested comparison (Mathesaurus):

Math synonyms

View more documents from Orest Ivasiv

Also, Hyperpolyglot provides nice comparison "Numerical Analysis Software: Fortran, MATLAB, R, NumPy".

Based on these two comparisons I've selected several factors for choosing the "right" numerical environments:

Commercial or open-source
Visualization possibilities
Language itself (MATLAB, Maple, R, etc.): computational specific or general purpose (Python, Clojure/Incanter, etc. )
Integration with Fortran/C/C++ etc.
GUI features

UML Sketching Tools

2012-02-13T01:18:00.000+02:00

UML drawing is painful in case your model should evolve very fast and you have to adjust it on the way. Such tool as Visio (and similar) is doing their job well till you don't need "aggressive" redrawing ;-) Have you ever tried to draw "huge" sequence, activity diagrams in Visio? I've "struggled" with grouping, layouting, styling, etc. So, I have decided to concentrate more on modelling and switched to "easy-going" UML tools also knowing as "Textual UML tools".
Here is the list of my favorite:

PlantUML - very powerful tool. It supports very intuitive diagram language. Seven diagram types, nice styling. And very good documentation.
UMLet - It's true sketching tool. Very very simple. And you shouldn't expect sexy UI ;-) BUT! It's so "right tool for the job". You just have to try it.
UMLGraph - It can be used to generate UML class and sequence diagrams. It has nice integration with javadocs tool.

I think that this Allen Holub's UML Quick Reference (example based and very pragmatic) might be helpful.

Quick way to join array of String in Java without third party libraries

2012-01-21T16:31:00.000+02:00

As you probably know Java SE doesn't include such useful method as String join. Even old good JavaScript has this nice method:

JavaScript join() Method
Definition and Usage
The join() method joins all elements of an array into a string, and returns the string. The elements will be separated by a specified separator. The default separator is comma (,).

How to implement the similar stuff in Java SE? The easiest what came to my head is:


 /**
  * Join String arguments into one String separated by comma (",")
  * @param args input Strings
  * @return joined String
  */
 public static String join(String... args) {
  if(args.length <1) throw new IllegalArgumentException();
  
  String joined = Arrays.toString(args);
  String result = joined.substring(1, joined.length()-1);
  return result;
 }

Usage is pretty trivial:


import static com.blogspot.HalypHUtils.join;

...

String joinedString = join("Banana", "Orange", "Apple", "Mango");

And as you've already noticed this join uses comma (",") separator only.

What is the best book for SCJP/OCPJP exam preparation?

2012-01-09T13:25:00.001+02:00

There are two major books for the exam preparation:

SCJP Sun Certified Programmer for Java 6 Exam 310-065, by Katherine Sierra, Bert Bates

A Programmer's Guide to Java SCJP Certification: A Comprehensive Primer (3rd Edition), by Khalid Mughal, Rolf Rasmussen

I've read both books and must admit that "SCJP Sun Certified Programmer for Java 6 Exam 310-065, by Katherine Sierra" is the best. You can also have a look into

OCP Java SE 6 Programmer Practice Exams (Exam 310-065) (Certification Press), by Bert Bates, Katherine Sierra
I can say it's like a companion book there are a plenty of nice mock exam questions.

I can say that you shouldn't use "A Programmer's Guide to Java SCJP Certification: A Comprehensive Primer (3rd Edition), by Khalid Mughal, Rolf Rasmussen" because:

there too many unnecessary info which is totally useless on exam
book written style isn't perfect, it's really hard to follow the main idea
explanation of some ideas is very complex and bloated, it can be simplified
book typographic style is really ugly in comparison with "SCJP Sun Certified Programmer for Java 6 Exam 310-065, by Katherine Sierra"

Your can simplify your exam preparation if you stick to one book. Keep in mind your goal is optimize the exam preparation and avoid the redundant reading.

How to decide which technology hype is worth personal investments?

2011-12-25T21:16:00.000+02:00

I think it's very important question. Because studding some new technology requires some time (and maybe money).

So, I've created for myself brief checklist which helps me to make this non-easy decision.

How long it will take for me to master the major approaches of selected technology?
Can I reuse the gained knowledge during my daily development work?
How long it will take to train/coach my team mates to use this technology?
How big is the market for the selected technology?
How big is the local community for the selected technology?
How easily can we hire new developers with appropriate knowledge in selected technology?
Will it be profitable to have the knowledge in that technology?

I know that some items are very boring and mercantile, but it's life, real life. And we should align our priorities appropriately.

How to run ANT script from .BAT/.CMD?

2011-11-03T15:04:00.003+02:00

Imagine you need to call ANT script from BAT/CMD file.
Ant script:

And here is BAT file:

@echo off
echo BAT - Before Ant run
ant -f build.xml
echo BAT - After Ant run

Unfortunately, when you run this BAT you get the next output:

BAT - Before Ant run
Buildfile: D:\Projects\blog\build.xml

bat-test:
     [echo] Message from ANT

BUILD SUCCESSFUL
Total time: 0 seconds

So, where is the "BAT - After Ant run" echo message?

The problem is that Ant on Windows executed via ant.bat file and based on this we're calling one BAT file from another. We have to use CALL command to solve this issues, here is official note from CALL help:

Calls one batch program from another.
CALL [drive:][path]filename [batch-parameters]
batch-parameters Specifies any command-line information required by the batch program.

And, here is the update BAT file:

@echo off
echo BAT - Before Ant run
call ant -f build.xml
echo BAT - After Ant run

Java Reflection: Invoke Constructor Issue

2011-10-21T12:37:00.000+02:00

Let's imagine we have the next classes:

package test.clazz;

public class First {
 private FirstArg arg;

 public FirstArg getArg() {
  return arg;
 }

 public First (FirstArg arg) {
  this.arg = arg;
  System.out.println("First() - constructor");
 }
}

public class FirstArg {
 public FirstArg() {
  System.out.println("FirstArg.FirstArg()");
 }
}

public class SecondArg  extends FirstArg{
 public SecondArg() {
  System.out.println("SecondArg.SecondArg()");
 }
}

And we can easily instantiate First class with FirstArg or SecondArg:

First f1Old = new First(new FirstArg());
First f2Old = new First(new SecondArg());
System.out.println(f1Old.getArg().getClass());
System.out.println(f2Old.getArg().getClass());

We'll get the next output:

FirstArg.FirstArg()
First() - constructor
FirstArg.FirstArg()
SecondArg.SecondArg()
First() - constructor
class test.clazz.FirstArg
class test.clazz.SecondArg

Now, we have to instantiate First class with FirstArg or SecondArg, but via Java reflection:

public final class ConstructionUtil {
 public static Object instantiateClassOld(String className, Object iView) {
  try {
   Class iViewClass = iView.getClass();
   Class clazz = Class.forName(className);

   Constructor ctor = clazz.getDeclaredConstructor(iViewClass);
   ctor.setAccessible(true);
   return ctor.newInstance(iView);
  } catch (Exception e) {
   e.printStackTrace();
   return null;
  }
 }
}

Check reflection based class instantiation:

Object cls = instantiateClassOld("test.clazz.First", new FirstArg());
First f1 = (First) cls;
Object cls2 = instantiateClassOld("test.clazz.First", new SecondArg());
First f2 = (First) cls2;
System.out.println(f1.getArg().getClass());
System.out.println(f2.getArg().getClass());

And we'll get Exception:

FirstArg.FirstArg()
First() - constructor
FirstArg.FirstArg()
SecondArg.SecondArg()
java.lang.NoSuchMethodException: test.clazz.First.(test.clazz.SecondArg)
 at java.lang.Class.getConstructor0(Unknown Source)
 at java.lang.Class.getDeclaredConstructor(Unknown Source)
 at test.ConstructionUtil.instantiateClassOld(ConstructionUtil.java:63)
 at test.ConstructionUtil.main(ConstructionUtil.java:22)

Reflection mechanism can't find First(SecondArg arg) constructor.
We have to patch instantiateClassOld method like this:

public final class ConstructionUtil {
 public static Object instantiateClassNew(String className, Object iView) {
  try {
   Class iViewClass = iView.getClass();
   Class clazz = Class.forName(className);
   try {
    Constructor ctor = clazz.getDeclaredConstructor(iViewClass);
    ctor.setAccessible(true);
    return ctor.newInstance(iView);

   } catch (NoSuchMethodException e) {
    Constructor[] constructors = clazz.getDeclaredConstructors();
    for (Constructor c : constructors) {
     if (c.getParameterTypes().length > 1)
      continue;
     Class type = c.getParameterTypes()[0];
     if (type.isAssignableFrom(iView.getClass())) {
      return c.newInstance(type.cast(iView));
     }

    }
   }
   return null;

  } catch (Exception e) {
   e.printStackTrace();
   return null;
  }
 }
}

And run it again:

Object cls = instantiateClassNew("test.clazz.First",new FirstArg());
First f1 = (First) cls;
Object cls2 = instantiateClassNew("test.clazz.First",new SecondArg());
First f2 = (First) cls2;
System.out.println(f1.getArg().getClass());
System.out.println(f2.getArg().getClass());

Output:

FirstArg.FirstArg()
First() - constructor
FirstArg.FirstArg()
SecondArg.SecondArg()
First() - constructor
class test.clazz.FirstArg
class test.clazz.SecondArg

We should be careful when invoke methods via reflection with polymorphic arguments.

Overview: Optimistic vs. Pessimistic Locking

2011-10-09T23:17:00.000+02:00

Data Concurrency is a real problem in multi-user environment. How can we manage the data consistence when several users try to modify the same record(s) at the same time?
This is a very interesting subject. Mostly, it's compromise. We can't easily pick one approach and forget about another.
This subject was quite nice discussed in Martin's Fowler book: "Patterns of Enterprise Application Architecture"

And, you can find here the short Martin's overview: Pessimistic Offline Lock and Optimistic Offline Lock.

JBoss community documentation has nice quotes about the subject:

The disadvantage of pessimistic locking is that a resource is locked from the time it is first accessed in a transaction until the transaction is finished, making it inaccessible to other transactions during that time. If most transactions simply look at the resource and never change it, an exclusive lock may be overkill as it may cause lock contention, and optimistic locking may be a better approach. With pessimistic locking, locks are applied in a fail-safe way. In the banking application example, an account is locked as soon as it is accessed in a transaction. Attempts to use the account in other transactions while it is locked will either result in the other process being delayed until the account lock is released, or that the process transaction will be rolled back. The lock exists until the transaction has either been committed or rolled back.

With optimistic locking, a resource is not actually locked when it is first is accessed by a transaction. Instead, the state of the resource at the time when it would have been locked with the pessimistic locking approach is saved. Other transactions are able to concurrently access to the resource and the possibility of conflicting changes is possible. At commit time, when the resource is about to be updated in persistent storage, the state of the resource is read from storage again and compared to the state that was saved when the resource was first accessed in the transaction. If the two states differ, a conflicting update was made, and the transaction will be rolled back.

The most popular example of optimistic locking is SVN commit operation.

Java Code Quality Tools - Overview

2011-08-31T01:06:00.002+02:00

Recently, I had a chance to present the subject at the local IT community meetup. Here is the basic presentation:

Java Code Quality Tools

and more meaningful mind map:

But, I think I need to cover this subject more deeply. This blog post should be something like start point for further investigation in this direction.

1. CodePro Analytix
It's a great tool (Eclipse plugin) for improving software quality. It has the next key features: Code Analysis, JUnit Test Generation, JUnit Test Editor, Similar Code Analysis, Metrics, Code Coverage and Dependency Analysis.
2. PMD
It scans Java source code and looks for potential problems: Possible bugs, Dead code, Suboptimal code, Overcomplicated expressions and Duplicate code.
3. FindBugs
It looks for bugs in Java programs. It can detect a variety of common coding mistakes, including thread synchronization problems, misuse of API methods, etc.
4. Cobertura
It's a free Java tool that calculates the percentage of code accessed by tests. It can be used to identify which parts of your Java program are lacking test coverage. It is based on jcoverage.
5. Emma
It is a fast Java code coverage tool based on bytecode instrumentation. It differs from the existing tools by enabling coverage profiling on large scale enterprise software projects with simultaneous emphasis on fast individual development.
6. Checkstyle
It is a development tool to help programmers write Java code that adheres to a coding standard.
7. JBoss Tattletale
JBoss Tattletale is a tool that can help you get an overview of the project you are working on or a product that you depend on. The tool will recursive scan a directory for JAR files and generate linked and formatted HTML reports.
8. UCDetector
UCDetector (Unecessary Code Detector) is a Open Source eclipse PlugIn Tool to find unecessary (dead) java code. It also tries to make code final, protected or private. UCDetector also finds cyclic dependencies between classes.
9. Sonar
Sonar is a continuous quality control tool for Java applications. Its basic purpose in life is to join your existing continuous integration tools to place all your development projects under quality control.
10. XRadar
The XRadar is an open extensible code report tool that produces HTML/SVG reports of the systems current state and the development over time. Uses DependencyFinder, JDepend, PMD, PMD-CPD, JavaNCSS, Cobertura, Checkstyle, XSource, JUnit, Java2HTML, ant and maven.
11. QALab
QALab consolidates data from Checkstyle, PMD, FindBugs and Simian and displays it in one consolidated view. QALab keeps a track of the changes over time, thereby allowing you to see trends over time. You can tell weather the number of violations has increased or decreased - on a per file basis, or for the entire project. It also plots charts of this data. QALab plugs in to maven or ant.
12. Clirr
Clirr is a tool that checks Java libraries for binary and source compatibility with older releases. Basically you give it two sets of jar files and Clirr dumps out a list of changes in the public api. The Clirr Ant task can be configured to break the build if it detects incompatible api changes. In a continuous integration process Clirr can automatically prevent accidental introduction of binary or source compatibility problems.
13. JDiff
JDiff is a Javadoc doclet which generates an HTML report of all the packages, classes, constructors, methods, and fields which have been removed, added or changed in any way, including their documentation, when two APIs are compared. This is very useful for describing exactly what has changed between two releases of a product. Only the API (Application Programming Interface) of each version is compared. It does not compare what the source code does when executed.
14. JLint
It checks your Java code and find bugs, inconsistencies and synchronization problems by doing data flow analysis and building the lock graph.
15. JDepend
JDepend traverses Java class file directories and generates design quality metrics for each Java package. JDepend allows you to automatically measure the quality of a design in terms of its extensibility, reusability, and maintainability to effectively manage and control package dependencies.
16. cloc
cloc counts blank lines, comment lines, and physical lines of source code in many programming languages.
17. Dependometer
Dependometer performs a static analysis of physical dependencies within a software system. Dependometer validates dependencies against the logical architecture structuring the system into classes, packages, subsystems, vertical slices and layers and detects cycles between these structural elements. Furthermore, it calculates a number of quality metrics on the different abstraction layers and reports any violations against the configured thresholds.
18. Hammurapi
Hammurapi is an open source code inspection tool. Its release comes with more than 100 inspectors which inspect different aspects of code: Compliance with EJB specification, threading issues, coding standards, and much more.
19. JavaNCSS

JavaNCSS is a simple command line utility which measures two standard source code metrics for the Java programming language. The metrics are collected globally, for each class and/or for each function.
20. DCD
DCD finds dead code in your Java applications.
21. Classycle
Classycle's Analyser analyses the static class and package dependencies in Java applications or libraries. It is especially helpful for finding cyclic dependencies between classes or packages. Classycle is similar to JDepend which does also a dependency analysis but only on the package level.
22. ckjm
The program ckjm calculates Chidamber and Kemerer object-oriented metrics by processing the bytecode of compiled Java files. The program calculates for each class the following six metrics proposed by Chidamber and Kemerer.
23. Jameleon
Jameleon is an automated testing framework that can be easily used by technical and non-technical users alike. One of the main concepts behind Jameleon is to create a group of keywords or tags that represent different screens of an application. All of the logic required to automate each particular screen can be defined in Java and mapped to these keywords. The keywords can then be organized with different data sets to form test scripts without requiring an in-depth knowledge of how the application works. The test scripts are then used to automate testing and to generate manual test case documentation.
24. DoctorJ
DoctorJ analyzes Java code, in the following functional areas: documentation verification, statistics generation and syntax analysis.
25. Macker
Macker is a build-time architectural rule checking utility for Java developers. It's meant to model the architectural ideals programmers always dream up for their projects, and then break -- it helps keep code clean and consistent. You can tailor a rules file to suit a specific project's structure, or write some general "good practice" rules for your code. Macker doesn't try to shove anybody else's rules down your throat; it's flexible, and writing a rules file is part of the development process for each unique project.
26. Squale
Squale is a qualimetry platform that allows to analyze multi-language software applications in order to give a sharp and comprehensive picture of their quality: High level factors for top-managers and Practical indicators for development teams.
27. SourceMonitor
The freeware program SourceMonitor lets you see inside your software source code to find out how much code you have and to identify the relative complexity of your modules. For example, you can use SourceMonitor to identify the code that is most likely to contain defects and thus warrants formal review.
28. Panopticon
The Panopticode project provides a set of open source tools for gathering, correlating, and displaying code metrics.
29. Eclipse Metrics plugin

Provide metrics calculation and dependency analyzer plugin for the Eclipse platform. Measure various metrics with average and standard deviation and detect cycles in package and type dependencies and graph them.
30. QJ-Pro
QJ-Pro is a comprehensive software inspection tool targeted towards the software developer. Developers can automatically inspect their Java source code and improve their Java programming skills as they write their programs. QJ-Pro provides descriptive Java patterns explaining error prone code constructs and providing solutions for it.
31. Byecycle
Byecycle is an auto-arranging dependency analysis plugin for Eclipse. Its goal is to make you feel sick when you see bad code and to make you feel happy when you see good code.
32. Coqua
Coqua measures 5 distinct Java code quality metrics, providing an overview and history for the management, and down-to-the-code, detailed views for the developer. Metrics can be defined per team. Ideal for mid- to large-sized and/or offshore projects.
33. Dependency Finder
Extracts dependencies and OO metrics from Java class files produced by most Java compilers.
34. Jalopy
Jalopy is an easily configurable source code formatter that can detect, and fix, a number of code convention flaws that might appear in Java code. Jalopy is more of a code fixer than a code checker. Jalopy plug-ins are present for most IDEs and, in most cases, they gel quite seamlessly with the IDE.
35. JarAnalyzer
JarAnalyzer is a dependency management tool for .jar files. JarAnalyzer will analyze all .jar in a given directory and identify the dependencies between each. Output formats include xml, with a stylesheet included to transform it to html, and GraphViz DOT, allowing you to produce a visual component diagram showing the relationships between .jar files. The xml output includes important design metrics such as Afferent and Efferent coupling, Abstractness, Instability, and Distance. There is also an Ant task available that allows you to include JarAnalyzer as part of your build script.
36. Condenser
Condenser is a tool for finding and removing duplicated Java code. Unlike tools that only locate duplicated code, the aim of Condenser is to also automatically remove duplicated code where it is safe to do so.
37. Relief
Relief provides a new look on Java projects. Relying on our ability to deal with real objects by examining their shape, size or relative place in space it gives a "physical" view on java packages, types and fields and their relationships, making them easier to handle. Lets discuss quickly how we interprete physical properties and how it can help us to grasp project characteristics.
38. JCSC
JCSC is a powerful tool to check source code against a highly definable coding standard and potential bad code. The standard covers naming conventions for class, interfaces, fields, parameter, ... . Also the structural layout of the type (class/interface) can be defined. Like where to place fields, either before or after the methods and in which order. The order can be defined through the visibility or by type (instance, class, constant). The same is applicable for methods. Each of those rules is highly customizable. Readability is enhanced by defining where to put white spaces in the code and when to use braces. The existence of correct JavaDoc can be enforced and various levels. Apart from that, it finds weaknesses in the the code -- potential bugs -- like empty catch/finally block, switch without default, throwing of type 'Exception', slow code.
39. Spoon
Spoon is a Java program processor that fully supports Java 5. It provides a complete and fine-grained Java metamodel where any program element (classes, methods, fields, statements, expressions...) can be accessed both for reading and modification. Spoon can be used on validation purpose, to ensure that your programs respect some programming conventions or guidelines, or for program transformation, by using a pure-Java template engine.
40. Lint4j
Lint4j ("Lint for Java") is a static Java source and byte code analyzer that detects locking and threading issues, performance and scalability problems, and checks complex contracts such as Java serialization by performing type, data flow, and lock graph analysis.
41. Crap4j
Crap4j is a Java implementation of the CRAP (Change Risk Analysis and Predictions) software metric – a mildly offensive metric name to help protect you from truly offensive code.
42. PathFinder
Java PathFinder (JPF) is a system to verify executable Java bytecode programs. In its basic form, it is a Java Virtual Machine (JVM) that is used as an explicit state software model checker, systematically exploring all potential execution paths of a program to find violations of properties like deadlocks or unhandled exceptions. Unlike traditional debuggers, JPF reports the entire execution path that leads to a defect. JPF is especially well-suited to finding hard-to-test concurrency defects in multithreaded program
43. Soot
Soot can be used as a stand alone tool to optimize or inspect class files, as well as a framework to develop optimizations or transformations on Java bytecode.
44. ESC/Java2
The Extended Static Checker for Java version 2 (ESC/Java2) is a programming tool that attempts to find common run-time errors in JML-annotated Java programs by static analysis of the program code and its formal annotations. Users can control the amount and kinds of checking that ESC/Java2 performs by annotating their programs with specially formatted comments called pragmas.

* * *

This list includes open sourced and free tools. I intentionally have excluded commercial tools. I'm sure there are much more tools. In case your know some of them which isn't listed here please add comment to this post.

My reflection on "Programming Achievements: How to Level Up as a Developer"

2011-08-14T23:52:00.003+02:00

Recently, I've read an amazing blog post "Programming Achievements: How to Level Up as a Developer". Also, it worth to read comments to this post, they are really interesting, subjective and personal. But, in any case you'll get something to think about. How to measure your own professional achievements, different ways for improvements and some start point for planning all these stuff.

The author suggests to use GitHub Gist as a natural way of improvements to keep them tracking. So, I've just forked his gist and performed several initial changes (see https://gist.github.com/1141765):

IT Booze Meetup #2: Scala, Clojure, Groovy

2011-07-30T15:11:00.002+02:00

Today, I had a chance to attend local user group IT Booze. It was the second meetup and it was very interesting, because of topics which were under discussion: Scala, Clojure And Groovy. I love such events especially in my town. :-)

I'd like to share my reflections regarding these cool languages.

As you know these languages are very popular on JVM (of cause not so popular as Java :-). And I'm sure every passionate Java/JVM developer has been thinking "what's the Next Big Language". It's really hard to choose the next one.

So, here is a short "brain snapshot":

Scala and Clojure are great languages with huge amount of interesting features, but to master them we need to use Scala (or Clojure) on daily basis.
Scala appeared as complex language. I think it requires a steeper learning curve then Clojure or Groovy. It means we must invest much, much more.
Clojure has lisp syntax, but innovative concurrency concept is worth to look into. I say lisp, because it might be a stopper for someone to evaluate it as a next big language.
Clojure and functional programming require to "patch" our way of thinking. And it can be difficult.
Groovy is agile language. We (Java developers) can start using it right away. I think we should invest more in Groovy just to boost our productivity in: scripting, testing, automation routine work, etc. It doesn't require big investments and we can learn as we go.

So, here is outcome from this meetup:

start using Groovy
look into Clojure concepts
postpone Scala for now

Could you please share your thoughts regarding this?

How to disable System.out?

2011-07-20T22:29:00.001+02:00

I have a legacy code base with tons of System.out.println(). Actually, I don't need this in production, but during development it's cool enough to have. So, I've decided to disable System.out:

package org.halyph;

import java.io.OutputStream;
import java.io.PrintStream;

public class DisableMain {
	public static void main(String[] args) {
		PrintStream printStreamOriginal = System.out;

		boolean DEBUG = true;
		if (!DEBUG) {
			System.setOut(new PrintStream(new OutputStream() {
				public void close() {}
				public void flush() {}
				public void write(byte[] b) {}
				public void write(byte[] b, int off, int len) {}
				public void write(int b) {
				}
			}));
		}

		long a = System.currentTimeMillis();
		for (int i = 0; i < 1000000; i++) {
			System.out.println("Hello");
		}

		long b = System.currentTimeMillis() - a;

		System.setOut(printStreamOriginal);
		System.out.println(b);
	}
}

So, plain looped println required ~10 seconds on my laptop, and only ~1 second with null output stream.

Ubuntu Server 10.04.2 VM Basic Configuration

2011-07-19T00:45:00.002+02:00

+ +

Required tools:

VMware Worstation
Ubuntu Server 10.04.2
Kitty (Putty ssh client fork)

I suppose that You know how to setup plain VM via VMware.
And here is my basic Ubuntu VM configuration:

Ubuntu Server 10.04.2 doesn't include SSH server by default. That's why you have to install it:

sudo apt-get install ssh

Check your Ubuntu VM IP:

$ ifconfig
eth0      Link encap:Ethernet  HWaddr 00:0c:29:04:55:d6
          inet addr:192.168.11.134  Bcast:192.168.11.255  Mask:255.255.255.0
          inet6 addr: fe80::20c:29ff:fe04:55d6/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:50 errors:0 dropped:0 overruns:0 frame:0
          TX packets:52 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:6303 (6.3 KB)  TX bytes:7366 (7.3 KB)
          Interrupt:19 Base address:0x2000

Configure Kitty connection host name:
Create two scripts for:

startup VM in background (start_vm.bat)

set MYVM="F:\VMs\ubuntu-10.04.2-server\Ubuntu Server 10.04.2.vmx"
set VMRUN="E:\Program Files\VMware\VMware Workstation\vmrun"

%VMRUN% -T ws start %MYVM% nogui

shutdown VM (stop_vm.bat)

set MYVM="F:\VMs\ubuntu-10.04.2-server\Ubuntu Server 10.04.2.vmx"
set VMRUN="E:\Program Files\VMware\VMware Workstation\vmrun"

%VMRUN% stop %MYVM% soft

Configure Kitty for auto-login:
VM startup and Kitty run can be combined into one script

Clojure Books

2011-07-11T22:00:00.001+02:00

Published

Books which aren't fully dedicated to Clojure

Coming Soon (in progress)

How to Add Jars at Runtime?

2011-06-28T13:34:00.000+02:00

Suppose you have the next project structure:

Here is the source code:

package org.halyph.one;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.CodeSource;

import org.halyph.three.MyClassThree;
import org.halyph.two.MyClassTwo;

public class DynamicClassLoader {
 public static void main(String[] args) throws Exception {
  System.out.println("DynamicClassLoader.main()");

  MyClassTwo myClassTwo = new MyClassTwo();
  MyClassThree myClassThree = new MyClassThree();
  myClassTwo.printMessage();
  myClassThree.printMessage();

 }
}

package org.halyph.two;

public class MyClassTwo {
 public void printMessage() {
  System.out.println("MyClassTwo.printMessage()");
 }
}

package org.halyph.three;

public class MyClassThree {
 public void printMessage() {
  System.out.println("MyClassThree.printMessage()");
 }
}

And each of these classes are packed in separate jar:

org.halyph.one.DynamicClassLoader - dynone.jar
org.halyph.two.MyClassTwo - dyntwo.jar
org.halyph.three.MyClassThree - dynthree.jar

To run this application you should put all these jars on classpath,
E.g. the application output

# java -cp dynone.jar;dyntwo.jar;dynthree.jar org.halyph.one.DynamicClassLoader
DynamicClassLoader.main()
MyClassTwo.printMessage()
MyClassThree.printMessage()

But there are some cases when dyntwo.jar and dynthree.jar jars location can be known during runtime only. And we have to run our application in the next way:

# java -cp dynone.jar org.halyph.one.DynamicClassLoader

Of cause, you'll get the next (or similar) error:

# java -cp dynone.jar org.halyph.one.DynamicClassLoader
DynamicClassLoader.main()
Exception in thread "main" java.lang.NoClassDefFoundError: org/halyph/two/MyClassTwo
        at org.halyph.one.DynamicClassLoader.main(DynamicClassLoader.java:28)
Caused by: java.lang.ClassNotFoundException: org.halyph.two.MyClassTwo
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        ... 1 more

So, how can we solve this problem?
Here is the patched org.halyph.one.DynamicClassLoader:

package org.halyph.one;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.CodeSource;

import org.halyph.three.MyClassThree;
import org.halyph.two.MyClassTwo;

public class DynamicClassLoader {

 public static void main(String[] args) throws Exception {
  System.out.println("DynamicClassLoader.main()");

  String[] jars = new String[] { "dyntwo.jar",  "dynthree.jar"};
  addJarsToClasspath(getRootFolder(), jars);
  MyClassTwo myClassTwo = new MyClassTwo();
  MyClassThree myClassThree = new MyClassThree();
  myClassTwo.printMessage();
  myClassThree.printMessage();

 }

 public static void addJarsToClasspath(String rootFolder, String[] jarNames)
   throws SecurityException, NoSuchMethodException,
   MalformedURLException, IllegalArgumentException,
   IllegalAccessException, InvocationTargetException {

  Method addURL = URLClassLoader.class.getDeclaredMethod("addURL",
    new Class[] { URL.class });
  addURL.setAccessible(true); // you're telling the JVM to override the
         // default visibility

  File[] files = new File[jarNames.length];
  int i = 0;
  for (String jarName : jarNames) {
   files[i++] = new File(rootFolder + jarName);
  }

  // returning the jars to add
  ClassLoader cl = ClassLoader.getSystemClassLoader();
  for (i = 0; i < files.length; i++) {
   URL url = files[i].toURL();
   addURL.invoke(cl, new Object[] { url });
  }
 }

 public static String getRootFolder() {
  String result = null;
  try {
   String qualifiedClassName = DynamicClassLoader.class.getName();

   Class qc = Class.forName(qualifiedClassName);
   CodeSource source = qc.getProtectionDomain().getCodeSource();
   if (source != null) {
    URL location = source.getLocation();
    File file = new File(location.toURI());

    result = file.getParent() + "/";
   } else {
    System.out.println(qualifiedClassName + " : "
      + "unknown source");
   }
  } catch (Exception e) {
   System.err.println("Unable to locate class on command line.");
   e.printStackTrace();
  }
  return result;
 }

}

Here is the output of patched application:

# java -cp dynone.jar org.halyph.one.DynamicClassLoader
DynamicClassLoader.main()
MyClassTwo.printMessage()
MyClassThree.printMessage()

So, two additional methods were added to support this "magic":

public static String getRootFolder()- this method simply identifies the folder where dynone.jar (on behalf of org.halyph.one.DynamicClassLoader class) is located. Because for this demo we put all application-related jars in one folder
public static void addJarsToClasspath(String rootFolder, String[] jarNames) - and here the "magic" happen. Based on this post on www.velocityreviews.com forums:

There is a well-known hack for dynamically extending the class path.
It generally works, and we use it in production releases of our software. It uses reflection, plus the knowledge that the default ClassLoader *is* a URLClassLoader.
...
As I said, this is a hack, undocumented, and subject to change at any
time. Indeed, there's no guarantee that extant JREs use a URLClassLoader as a default class loader. Moreover, it only works if your program doesn't have a security manager (it probably doesn't), or your code is trusted.
...
We've never seen problems with it, although our software is used on a plethora of different boxes and OSs.

It works for me and I hope it will be useful for you as well.
Happy hacking!

@Override Java Annotation Issue

2011-06-19T23:55:00.000+02:00

Let's create one simple interface and class which implements this interface:

public interface IOverride {
    void doSomething();
}
public class Overridden implements IOverride {
    @Override
    public void doSomething() {
    }
}

And compile this stuff on JDK v.1.5:

# javac -d classes src\*.java
src\Overridden.java:2: method does not override a method from its superclass
        @Override
         ^
1 error

Let's try to do the same on JDK v.1.6 - And, You've got no compilation error.

Between Java 5 and Java 6 changes to the specification of @Override have been made. In Java 6 it is possible to add the @Override annotation to methods that implement methods of an interface which is not allowed in Java 5. (http://dertompson.com/2008/01/25/override-specification-changes-in-java-6/)

Also, I've found very interesting discussion on Stackoverflow: http://stackoverflow.com/questions/94361/when-do-you-use-javas-override-annotation-and-why:

Q:

What are the best practices for using Java's @Override annotation and why?
It seems like it would be overkill to mark every single overridden method with the @Override annotation. Are there certain programming situations that call for using the @Override and others that should never use the @Override?

Use it every time you override a method for two benefits. Do it so that you can take advantage of the compiler checking to make sure you actually are overriding a method when you think you are. This way, if you make a common mistake of misspelling a method name or not correctly matching the parameters, you will be warned that you method does not actually override as you think it does. Secondly, it makes your code easier to understand because it is more obvious when methods are overwritten.

Additionally, in Java 1.6 you can use it to mark when a method implements an interface for the same benefits. I think it would be better to have a separate annotation (like @Implements), but it's better than nothing.

ITEvent 2011, Local Conference – Report

2011-06-12T01:28:00.000+02:00

Yesterday (June 11, 2011) I attended the local (Ivano-Frankivsk, Ukraine) IT related conference “itEvent 2011”. I must say I am impressed. There were more than a hundred participants. And it’s amazing. We live in a very small city and this local event/conference waked up so many developers to attend this event.

The conference had three parallel flows/stages. And it’s a good sign. The organizers give us a chance to choose the most preferable topic(s) to attend. Additional good point is that each presentation was shot on video. So, I could see missed interesting topics.

Here is the talks (which I saw and hear) overview:

1. “Two sides of IT interview” by Nataliya Mukhitdunova. To tell the truth I wasn’t expected that such boring subject can be presented in such interesting way. Just wow. The speaker was concentrated on two interview stakeholders: HR and Developer. She clearly defined their goals and expectations, tips for HRs (as interviewer) and for Developers (as interviewee). And this speech was so easy made and “light” that I felt “I’m in right place in right time”. The presenter doesn’t use any slides or other supportive material, she was just well prepared with good background in this area.

2. “Kanban and the creation of the high effective teams” by Sergiy Fitsak and Anatoliy Okhotnikov. I’ve expected to hear some advices, case studies (especially BAD experience) and of cause the process implementation issues. And I’ve got all these. Thanks to the presenters. The one “minus” was that this talk wasn’t well coordinated between two presenters and they overused the presentation’s time limit. They hadn't predicted that they got so many questions and discussions. I can say that this talk really revived the audience. And it was cool.

3. “Facebook as a mobile application platform” by Yevgen Vershynin. The presenter showed us from the very begging what the Facebook platform is and how to use it. This area was absolutely new for me. Additionally, he was well prepared and his speech was very dynamic. And, even more, he showed some passion during the speech. That’s why it was so interest. I must admit that Yevgen (the presenter) showed very high presentation, communication skills, and good domain knowledge. Very impressive.

4. “How to meet customer expectations” by Ruslan Seredyuk. This topic was absolutely new for me. I mean I’ve never thought about “customer expectations” and “what is the successful project”. I like to discover something new. The presenter showed real knowledge which is based on work experience. And it’s very important. Every single case in his presentation had small life sample, which was very useful to demonstrate the all dark places in this mess area (i.e. customer expectations). Again, the presenter was well prepared with real case studies. The one "minus" is that the target audience wasn’t mentioned. And this topic wasn’t dedicated for the junior developers, IMHO.

Now, let’s talk about conference organizations:

Pros:

1. There were a lot of coffee, cakes and water.

2. The registration was straightforward.

3. The atmosphere was VERY friendly.

4. The presentations' quality was good.

5. And the most important, the itEvent organizer overdid their own expectation, they gathered huge amount of IT related people in one place and gave them a chance to talk to each other and share personal knowledge, vision and contacts. As for me, the goal was perfectly achieved.

Cons:

1. I think that Conference, Camp or similar event should have some motto.

2. It’s good to have agenda for every presentation/speech in English as well

3. It’s good to have target audience for every presentation/speech. It’s even more important in multi-target conference (here we can see management, technical and usability directions, etc.)

4. The conference’s web resource is in Ukrainian only. It’s good to have English as well. Also, the web resource structure could be improved.

So, the overall impression is good. This local conference exceeded my expectations. I hope we’ll have the similar event next year.

Top 15 Java Web Resources

2011-06-06T00:41:00.003+02:00

Here is the top 15 Java-related resources I'd like to share with you.

Blogs, News aggregator

	1. http://www.dzone.com is a very big aggregator for news, articles, video interviews, tutorials, reviews, and announcements. Also, you can use some particular, dedicated "zones": http://java.dzone.com - Javalobby IDEs and Tools: http://eclipse.dzone.com http://jetbrains.dzone.com http://netbeans.dzone.com This resource contains huge amount of information and you could easily lost there (50-80 new items per day). So, I suggest to use Javalobby as a start point.
	2. http://www.infoq.com News, videos, interviews, conference reports, etc.
	3. http://www.java.net Articles, blogs, wiki, news.

Forums and Q&A

	4. http://www.javaranch.com is one of the biggest Java forum
	5. http://stackoverflow.com it's one of the biggest Q&A site which includes such features as Q&A, forum, wiki, blog, collaboration and community based content moderation.

Videos

	6. http://www.java-tv.com Java-TV.com is a directory of videos, interviews and tutorials focused on software development activities with the Java™ programming language.
	7. http://www.softdevtube.com SoftDevTube is a repository of videos, interviews and tutorials focused on all software development activities.

Cookbooks

	8. http://www.discursive.com/book/322 Common Java Cookbook This collection provides expert tips for using Java-based utilities from projects such as Apache Commons, Apache Lucene, and Apache Velocity. You don't have to be an expert, the book's solution-based format contains code examples for a wide variety of web, XML, network, testing, and application projects. If you want to learn how to combine common open-source Java utilities to create powerful Java applications and tools, the Common Java Cookbook is for you.
	9. http://mindprod.com/jgloss/jgloss.html Canadian Mind Products Java & Internet Glossary
	10. http://www.javapractices.com/home/HomeAction.do Collected Java Practices. It offers concise presentations of Java practices, tasks, and designs, illustrated with syntax-highlighted code examples.
	11. http://www.leepoint.net/notes-java/index.html Java Notes. These Java programming notes are written to fill in missing or weak topics in textbooks the Author has taught from.
	12. http://www.javamex.com Javamex is the author attempt to gather together information on some of the more intricate aspects of Java programming, building on the experience with the language.
	13. http://www.exampledepot.com This site holds all the examples from The Java Developers Almanac and more. Copy and paste these examples directly into your applications. Over a thousand useful examples can be found there.

Other

	14. http://javatoolbox.com JavaToolbox.com references the tools you need for Java development.
	15. http://www.blackbeltfactory.com On-line community-based exam system

How to choose between Scala and Clojure?

2011-06-01T00:55:00.003+02:00

vs.

I think it's very popular question nowadays. The Java-haters produce so many buzz around this. So, want you or not, but You passively have been trying to choose the Java.next().

I've found several interesting posts which cover pretty much about this subject:
by Stephan Schmidt

by Lau B. Jensen

Others

Hint: Try to read comments to these posts, there are very interesting discussions. Some of them are even more useful than the actual post(s)/article(s).

These articles don't give you any advices or strong opinions which language is the best. But, it's a good start point, for sure.

JEEConf - Kiev, 2011 - Report

2011-05-23T23:41:00.002+02:00

I had a chance to attend the first and totally dedicated to Java conference in Kiev (May 21, 2011).
It was a great. The atmosphere was amazing. The organization was good, really good. The most noticeable thing was that almost every presentation was based on real problem, no metaphysical stuff :-)
There were three stages, that's why I couldn't attend every talk and that's a pity.

Here is a short overview of all attended talks:

1. "What Riding the Camel can do to make integration easier for you" by Claus Ibsen.
I had an idea what the Camel is, but this presentation gave me the "big picture". Actually, the speaker has been well prepared and known the presentation technique very well. He showed all major aspects of Camel framework and explain its purpose.

He's shown the several Camel's DSLs: XML-based, Java and Scala. That short code snippets were really cool and clean. So, I've added into my todo list "the Camel DSL digging" ;-)

2. "The Scala and GridGain usage for the distributed systems with high efficiency" by Renat Ahmerov.
This talk and master-class inspired me to start Scala learning. I've never seen the cloud computing in action. But during that master-class was created real application for distributed computing. And the code base was so tiny and clean, so my heart falling in love to this language. The last time I had had the similar feeling when I've seen the Rails in action.

3. The problem diagnosing and GC tuning in HotSpot Java VM by Vladimir Ivanov.
This talk was like a JVM magic :-). The speaker discovered the darkest GC places I've never known about. He's opened my eyes. I even couldn't expect that GC tuning is so interesting.

4. To be in ten times faster kudos Groovy by Evgeny Kompaniec
This guy has shown the real case study:
- Why he choose the Groovy as Java substitution.
- Java code snippets vs Groovy (functionally equal) code snippets. IMHO, the most interesting and inspiration part of talk.
- Groovy knowledge sharing via pros & cons.

5. Unitils for Java testing by Mikalai Alimenkou
To be honest I've never heard about this tools. This presentation was full of practical samples and advices like a cookbook. Great talk, the presenter had a good mood and used the right jokes in the right places, he was very impressive. I wish every speaker had such good presentation technique.

6. How Graph Databases can make you a super star by Andrés Taylor
This talk was dedicated to the "beauty" of Neo4j graph DB. It was just a start point for this DB.

7. Vaadin, Rich Web Apps in Server-Side Java without Plug-ins or JavaScript by Joonas Lehtinen
I've been following this framework about a year. And I must admit that it was really impressed to see CEO of company behind Vaadin.
The talk was short and pragmatic. The major areas of Vaadin were highlighted. Then, the presenter has shown the Vaadin in action and it was cool. The community and the whole framework evolved in one year. As for me it was great to see the real person who developed so interesting stuff.

It was my 6th IT conference. I must admit it was the best, no doubts. I hope to attend the Java conference next year again.