• Unittests takes times to write
  I'm even inclined to say that writing your tests should take at least the time as writing your functionality takes.
• Start with the unit tests
  Start writing your unittests first, setting up just enough of your classes to get the test compiling, this will force you write your test based on the functionality required not the buggy implementation you've just written.
• Independent
  as the name says, a unit test will test a single unit of code, use integration tests to see how parts are working together.
• Small
  A unit test should test a small bit of functionality, one class, or even one method. I usually write extra unittests that test entire use-cases, but those work next to the normal ones.
• Test negatives as wel as positives
  Your first test will probably check whether the functionality works when specifying the correct parameters , but also test whether the right results are returned or the correct exceptions are thrown when specifying the wrong ones.
• Use code coverage tools to measure effectiveness
  Coverage tools, like for instance Clover will tell you how much of your code is covered, and also which classes are the most risk (high complexy, low coverage)
• Be careful when using mock objects
  Using mock objects keeps your unittests indepent but it has the danger that you are testing your mock objects instead of your own functionality, write integration tests
• Don't change outputted results into asserts
  It can be very tempting to first see what your class outputs when running a test, and then writing asserts to test on those results, but you will just be validating that bug that is still in there.

Advantages of rest

• Works over HTTP, known protocol with known data formats (mime types), no weird ports open in your firewall
• Every resource is uniquely identified by a URI
• Can do CRUD on those resources (they are just called POST, GET, PUT, DELETE)
• used by all the major players for cloud applications (SUN's cloudApi, Microsoft's Azure services platform)
• we might finally get rid of webdav

I'll be using the Jersey Framework for this.
As i’ve been working on a backend that will allow you to manage agile development processes (Scrum, Kanban etc) I thought I use that.

In this application every object is represented by a Card for instance a Story, Task, Bug, work Item, etc.
Cards have a hierarchical structure and can each have custom properties
The class looks something like this (removed methods for clarity):

public abstract class Card {
	private long id;
	private List<Card> children = new ArrayList<Card>();
	private List<Entry> properties = new ArrayList<Entry>()
}

and then for instance the Story class with some default values set in the constructor:

public class Story extends Card {
	public Story() {
		addProperty("Title", "A new story");
		addProperty("Description", "as a .. I want .. for the benefit of ..");
		addProperty("Storypoints", "0");
	}
}

To be able to return these objects through REST they need to be in a format that can be distributed over HTTP, in this case we will be using XML and JSON.
The Java XML Bindings are perfectly suited to create xml representations of our classes

@XmlRootElement(name="card")
public abstract class Card {
	private long id;
 
	@XmlAttribute(name="type")
	protected String instance = this.getClass().getSimpleName();
 
	@XmlElement(name="card")
	private List<Card> children = new ArrayList<Card>();
 
	@XmlElement(name="property")
	private List<Entry> properties = new ArrayList<Entry>();
 
	@XmlAttribute
	public long getId() {}
}

* the Entry class is a simple class with a name and value property, I choose this approach as JAXB has an issue in representing HashMaps() in XML
this will produce the following xml

<card id="4" type="Task">
	<property value="nobody" name="assigned"/>
	<property value="Slay dragon" name="Title"/>
	<property value="his weak spot seems to be a small spot on his belly" name="Description"/>
	<property value="4" name="hours"/>
</card>

for JSON we don’t need to do anything special then include the jersey-json.jar to the project.

Now to configure and hookup the rest servlet
I added the jersey servlet to my web.xml

<servlet>  
    	<servlet-name>Rest Web Service</servlet-name>  
    	<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>  
    	<load-on-startup>1</load-on-startup>  
</servlet>  
<servlet-mapping>  
    	<servlet-name>Rest Web Service</servlet-name>  
    	<url-pattern>/services/*</url-pattern>  
</servlet-mapping>

And create the service provider class

@PerRequest
@Path("/agileassistant")
@Consumes({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
public class AgileAssistantService {
 ...
}

This will tell Jersey that this is a provider that will respond to requests to /rest/agileassistant, accept JSON and XML and can output JSON or XML depending on the accept headers sent by the client

Now if we for instance want to return the first card (rootCard) and all its children we add this method

	public static Card rootCard = Card.createCard(Root.class);
 
	@GET
	public Card getRoot() {
		return rootCard;
	}

(in my data model the rootCard is always present and functions as a starting point to add the rest of the cards in a hierarchical structure)
So requesting this card will effectively return the entire structure for my test data:

 
<card id="1" type="Root">
	<card id="2" type="Story">
		<property value="Convince King" name="Title"/>
		<property value="to let the prince go on an adventure" name="Description"/>
		<property value="5" name="Storypoints"/></card>
	<card id="3" type="Story">
		<card id="4" type="Task">
			<property value="nobody" name="assigned"/>
			<property value="Slay dragon" name="Title"/>
			<property value="his weak spot seems to be a small spot on his belly" name="Description"/>
			<property value="4" name="hours"/>
		</card>
		<card id="5" type="Task">
			<property value="nobody" name="assigned"/>
			<property value="Rescue Princess" name="Title"/>
			<property value="She'll be the one screaming from the tower window" name="Description"/>
			<property value="2" name="hours"/>
		</card>
		<property value="Once upon a time" name="Title"/>
		<property value="in a land far far away" name="Description"/>
		<property value="5" name="Storypoints"/>
	</card>
</card>

Doing a parameterized query is almost as easy

	@GET
	@Path("/card/{id}")
	public Card getCard(@PathParam("id") long id) {
		return getCardById(rootCard, id);
	}

here the id that you specify will be injected into the parameter
giving the following output

<card id="4" type="Task">
	<property value="nobody" name="assigned"/>
	<property value="Slay dragon" name="Title"/>
	<property value="his weak spot seems to be a small spot on his belly" name="Description"/>
	<property value="4" name="hours"/>
</card>

To conclude enabling rest for your applications is pretty easy, writing this blog took longer than writing the code.
In a next post I will add POST/PUT/DELETE requests to store data in your application

var someObject : bind myJavaclass.getProperty();

JavaFX needs to be aware of any changes to the bound variables to be able to update the related objects. It does this automagically for all javafx objects.
It seems JavaFX uses the Observer/Observable pattern for all its internal objects, well we can do the same to bind with JavaObjects.
To get myself familiar with JavaFX i decided to write a photoviewer/editor. This application has a java backend with in particular a Photo class which contains all the information of a certain picture, filename, path, tags, exif information etcetera

To get changes in the Java class to appear in the gui I create a PhotoAdapter javafx class that extends Observer and implemented the properties I need in my GUI.

public class PhotoAdapter extends Observer {
    public-read var filename: String;
    public-read var tags: String[];
    public-read var exif: String[];
 
    public-init var photo: Photo
         on replace {
            photo.addObserver(this);
            filename=photo.getFilename();
            tags = photo.getTags();
            exif = photo.getExif();
         };
 
    override function update(observable: Observable, arg: Object) {
        filename = photo.getFilename();
        tags = photo.getTags();
        exif = photo.getExif();
    }

after that I had my existing Java Photo class extend Observable and in every method that made changes I added the methods setChanged() and NotifyObservers() to inform the Observers about the change

public class Photo extends Observable {
    private Map<String, String> exifInformation; 
    ....
    public void setExifInformation(Map exifInfo) {
        this.exifInformation = exifInfo;
        setChanged();
        notifyObservers();
    }
}

in my main javafx class I can then use it as follows

    var photoAdapter = PhotoAdapter {
        photo : new Photo(startImage);
}

and use to fill a ListView swing object with for instance the tags:

    ListView {
        items:     bind photoAdapter.tags;
        width:     200;
        height:    300;
    }

et viola, thats all that there is to it