For those being around Rome next week… I’ll be presenting on the JBossWS project for the Rome’s JBoss User Group and Java User Group. More information available (in italian) at http://www.jugroma.it/wiki/jug/space/jug/eventi/Incontro+Aprile+2010 Also take a look at the Community Events calendar on JBoss.org, where every JBoss User Group event is listed.

Let’s hope the volcanic ash cloud goes away in the mean time

In this third post of our java2scala series we will take a look to variables and functions definition and use.

As usual you can find the full maven/eclipse project on github.

Java class

package it.javalinux.samples.java.post3;
 
class VariablesAndFunctions {
 
	private final String inputString;
 
	public int fooIntVar = 11;
	public final String fooStringVal = "fooString";
	private double privateIntVar = 1.1;
	private final String privateStringVal = "fooString";
 
	public VariablesAndFunctions(String inputString) {
		//it could compile! and if you uncomment the line tests will fail
		//inputString = inputString + "hasBeenModified";
		this.inputString = inputString;
		//it doesent compile because you have already assigned the final property
		//this.inputString = inputString + "hasBeenModified";
		System.out.println("Created VariablesAndFunctions with inputString=" + inputString);
	}
 
	public VariablesAndFunctions() {
		this("defaultString");
	}
 
	public String getInputString() {
		return inputString;
	}
 
	public String getFooStringVal() {
		return fooStringVal;
	}
 
// i. You can't re-assign a final variable
//	public void setFooStringVal(String fooStringVal) {
//		this.fooStringVal = fooStringVal;
//	}
 
	public double getPrivateIntVar() {
		return privateIntVar;
	}
 
	public void setPrivateIntVar(double privateIntVar) {
		this.privateIntVar = privateIntVar;
	}
 
	public int getFooIntVar() {
		return fooIntVar;
	}
 
	public String getPrivateStringVal() {
		return privateStringVal;
	}
 
	public void setFooIntVar(int fooIntVar) {
		this.fooIntVar = fooIntVar;
	}
 
}

java Unit Test

package it.javalinux.samples.java.post3;
 
import org.junit.Test;
 
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
 
public class VariablesAndFunctionsTest {
 
    @Test
    public void testAccessToPublicVar() {
    	VariablesAndFunctions instance = new VariablesAndFunctions();
    	instance.fooIntVar = 12;
    	assertTrue(instance.fooIntVar == 12);
    }
 
    @Test
    public void  testAccessToPublicVal()  {
    	VariablesAndFunctions instance = new VariablesAndFunctions();
    	// It doesn't compile...you can't reassign a final property
    	//instance.fooStringVal = "anotherString"
    	assertTrue(instance.fooStringVal.equals("fooString") );
    	assertFalse(instance.fooStringVal == new String("fooString") );
    }
 
    @Test
    public void  testAccessToPrivateVar()  {
    	VariablesAndFunctions instance = new VariablesAndFunctions();
    	instance.setPrivateIntVar(12);
    	assertTrue(instance.getPrivateIntVar() == 12);
    }
 
    @Test
    public void  testEmptyConstructor()  {
    	VariablesAndFunctions instance = new VariablesAndFunctions();
    	assertTrue(instance.getInputString().equals("defaultString"));
    	assertFalse(instance.getInputString() == new String("defaultString") );
    }
 
    @Test
    public void  testConstructor()  {
    	VariablesAndFunctions instance = new VariablesAndFunctions("myString");
    	assertTrue(instance.getInputString().equals("myString"));
    	assertFalse(instance.getInputString() == new String("myString") );
    }
 
}

Scala class

package it.javalinux.samples.scala.post3
 
class VariablesAndFunctions(val inputString : String) {
 
    println("Created VariablesAndFunctions with inputString=" + inputString);
 
    // it doesnt compile
    // inputString = inputString + "hasBeenModified";
 
	def this() = this("defaultString")
 
	var fooIntVar : Int = 11
	val fooStringVal = "fooString"
	private var privateIntVar = 1.1
	private val privateStringVal = "fooString"
 
	def getPrivateVarIntVar() = privateIntVar
 
	def getPrivateStringVal() = privateStringVal
 
	def setPrivateVarIntVar(x : Int) {
	  privateIntVar = x
   	}
 
// It doesn't compile...you can't reassign val
//	def setPrivateStringVal(s : String) {
//	  privateStringVal = s;
//    }
 
}

Scala Unit Test

package it.javalinux.samples.scala.post3
 
import org.junit._
import Assert._
 
@Test
class VariablesAndFunctionsTest {
 
    @Test
    def testAccessToPublicVar() = {
    	val instance = new VariablesAndFunctions()
    	instance.fooIntVar = 12
    	assertTrue(instance.fooIntVar == 12)
    }
 
    @Test
    def testAccessToPublicVal() = {
    	val instance = new VariablesAndFunctions()
    	// It doesn't compile...you can't reassign val
 
    	//instance.fooStringVal = "anotherString"
    	assertTrue(instance.fooStringVal == new String("fooString") )
        assertFalse(instance.fooStringVal eq new String("fooString") )
    }
 
    @Test
    def testAccessToPrivateVar() = {
    	val instance = new VariablesAndFunctions()
    	instance.setPrivateVarIntVar(12)
    	assertTrue(instance.getPrivateVarIntVar == 12)
    }
 
    @Test
    def testEmptyConstructor() = {
    	val instance = new VariablesAndFunctions()
    	assertTrue(instance.inputString == new String("defaultString") )
        assertFalse(instance.inputString eq new String("defaultString") )
    }
 
    @Test
    def testConstructor() = {
    	val instance = new VariablesAndFunctions("myString")
    	assertTrue(instance.inputString == new String("myString") )
        assertFalse(instance.inputString eq new String("myString") )
    }
 
}

Ok, let me rapidly focus on some interesting things we can remark in previously pasted code (of course feel free to ask if I’ve missed to remark something that you’d like more explanations):

• public is the default access modifier…conciseness one more time. Scala have 3 different access public (default), private and protected. While plublic and private are the same of java, protected is a bit more restrictive than java one: protected member can be accessed only by subclasses of the class in which they are defined; in java you can access protected memeber also by classes defined in the same package. In scala you can achieve this effect using scoped protection. I will explain that in further post: for the moment just take in mund that you can specify private[X] or protected[X] member meaning they are private or protected “up to” X where X could be an enclosing package or class.
• scala has 2 different keyword to define mutable (var) and immutable variable. Immutable variable guarantee immutable state at compile time.
• default constructor is defined implicitly in class definition:
  • every code put in the class except variables and methods definitions are considered part of the default constructor. In our case the println instruction for debug purpose.
  • every val defined into calss definition parenthesis act as parameter for the default constructor. It’s matter of facts that the inputString parameter is defined as val prevent any kind of modification. Of course you can do the same in java declaring the input parameter as final, but it’s quite less usual.
• normally in scala public variables are accessed using variables names instead of odd getter and setter methods. BTW there is an annotation in scala to build getter and setter methods runtime. It is useful when you need java bean compatible objects written in scala.
• a method or function is defined using keyword def
• functions are methods that returns value. Normally defined using an = symbol after method name. Normally return keyword is not required and its use isn’t suggested, the last expression evaluated in the method is the returned one. Try to think functions as complex expression evaluation. Normally you don’t need to specify the type of returned value in method definition since scala will infer it for you. We will see type inference in one of next posts. For now just keep in mind that COMPILER will STATICALLY infer type for you.
• The same STATIC inference of type is used to infer variable type when it isn’t specified. Try to play a little with my code to get idea about type inference of scala. It’s AMAZING.
• methods without = symbol doesn’t return value. Formally they return an instance of Unit. Unit is the type of scala like void for java.
• Don’t miss the different behaviour of == on object between scala and java. They are used in unit tests. Scala uses == to compare the content of objects, while it have eq operator to compare object references.

Ok that’s all for the moment, but as said feel free to play with my code and/or ask here any further explanations.

In next post of the series we will take a first look at scala’s type inference in some more detail. As said it’s absolutely AMAZING…stay tuned

Seasoned java developers know that the infamous java.lang.NoClassDefFoundError you can get at runtime might be due to a lot of different issues, the most trivial being libraries missing in classpath.

Of course tracking down the real problem might result quite more complex when multiple classloaders are involed. Things get even more subtle when the bootstrap classloader comes into play

I usually deal with a project requiring a couple of libraries to be installed to and loaded from a location specified when providing the virtual machine with the endorsed dir parameter (-Dendorsed.dirs=my_endorsed_dir). I’m not spending a lot of words on the reason for doing so, it should be enought to know I need to overwrite some classes already shipped with the JDK.

As you know the classes in libraries added to the endorsed dirs are loaded by the bootstrap classloader, before the system classloaders do their job with the other classes.

Yesterday I was adding a new API (interfaces only) to another module (ModuleB) of my project. After that I implemented the interfaces in my ModuleA, which builds to a jar that goes to endorsed dir. Compile phase all green, but NoClassDefFoundError at runtime.

Exception in thread “main” java.lang.NoClassDefFoundError: it/javalinux/blog/Foo
at java.lang.ClassLoader.findBootstrapClass(Native Method)
at java.lang.ClassLoader.findBootstrapClass0(ClassLoader.java:891)
at java.lang.ClassLoader.loadClass(ClassLoader.java:301)
at java.lang.ClassLoader.loadClass(ClassLoader.java:299)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:268)
at java.lang.ClassLoader.loadClass(ClassLoader.java:251)
at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:319)

The classpath is OK. The libraries contain all the classes, including the Foo class. What’s happening then?

Well, I definitely did a mistake, ie. I put the Foo class in ModuleA while it implements FooInterface from ModuleB. Nothing dangerous in that besides *only one* of them is loaded by the bootclassloader, hence the NoClassDefFoundError.The Foo class is indeed available, but it’s loaded by another classloader.

So, aways think about the way your project classes are loaded and… look carefully at the exception dump, even in the java.lang.Classloader package section

This post is to let you know a really interesting event that’s taking place soon in Genoa (Italy): the Java Application Server Day 2009.

As you can read on www.serverday.org, the event will be open to the entire Italian Java Community; international experts, developers and students will discuss the state of the art
and the future of Java Application Servers, with a focus on the innovations of
the recently released JBoss 5.0, Spring dm Server, GlassFish 3.0 & Oracle/WebLogic.

I’ve been asked to be there on behalf of JBoss / Red Hat, so I’ll present the recent changes in JBoss AS 5.

Hope you can join the event on May, 21st. Stay tuned for further updates.

According to this analyzer I’m  The Duty Fulfillers

The responsible and hardworking type. They are especially attuned to the details of life and are careful about getting the facts right. Conservative by nature they are often reluctant to take any risks whatsoever.
The Duty Fulfillers are happy to be let alone and to be able to work int heir own pace. They know what they have to do and how to do it.

It doesn’t perfectly fit on my personality, but for sure it isn’t too far.

Thanks to Mark Little for the link