JRoller

CA's Open Source Farce

Rob Williams — Tue, 24 Nov 2009 14:38:22 -0500

So there has been a lot of talk lately about how Open Source is really turning into 'Yeah, so let's do this: you do all the work, then if it's worth a damn, a couple sharks will take it to the marketplace and make a fortune and you'll get bubkiss..' I would love to see some interviews with the original MySQL team, see how they feel about the fact that one of Satan‘s minions is about to take ownership of their love child.

So this morning, SDTimes had an article about how Computer Associates has created an Agile management tool and their plan is to create a community around it, get a bunch of developer feedback and help, then go and commercialize it. Am I missing something? Or is this the sign that we are in the second capitulation where tragedy turns to farce? (Of course, it reminded me of the Eighteenth Brumaire article where Marx says history repeats itself, first as tragedy, then as farce.. (for any other Randian or otherwise nutballs lurking, it is possible to read Marx without believing that we all ought live in a commune…)).

Downloading CSV, Excel files in GWT

Dhaval Dalal — Tue, 24 Nov 2009 11:28:25 -0500

Alright, this one needs some plumbing, I would have expected GWT to provide some out-of-box solution for this one (just like the File-Upload widget), as its a very common feature needed by almost all web applications. Anyways, quite a bit of server-side and client-side plumbing needs to be done in order to achieve this functionality.

First of all, when a user clicks a download link or button, this has to be a Synchronous request and cannot work with the Aynchronous callback handler that GWT provides. So, I have broken this post in two parts:
A. The Client-Side Plumbing.
B. The Server-Side Plumbing.

Also, I have BDDed the design and won't show the Scenarios and Specs, instead will focus on the key design components in this post.

A. The Client-Side Plumbing:

Starting from the UI, I have created a SyncAction representing the concept of Synchronous Action with a single method execute() on it.
```
public interface SyncAction {
	public abstract void execute();
}
```

DownloadCsvAction is a implementation of SyncAction. So, basically, populate this action with a Url and fire execute()...thats all! Inside the execute() method, I had to make a GET synchronous request to Server Resource on HiddenIFrame. This will ensure that we do not refresh the page that we are already in. Once execute(), is called, the server-side starts processing the incoming request.

public class DownloadCsvAction implements SyncAction {
	
	private String encodedUrl;
	
	public void setEncodedUrl(String encodedUrl) {
		this.encodedUrl = encodedUrl;
	}

	public void execute() {
		HiddenIFrame frame = new HiddenIFrame(encodedUrl);
	}
}

Here is the HiddenIFrame class (I obtained this from one of the blogs and have renamed to HiddenIFrame a more meaningful name, thanks to the author, but don't recollect the blog-url, sorry!).

public class HiddenIFrame extends Frame {
   
   public HiddenIFrame(String url) {
      super();
      setSize("0px", "0px");
      setVisible(false);
      sinkEvents(Event.ONLOAD);
      // TODO: Add Form here so that it will POST instead of GET
      RootPanel.get().add(this);
      // Do a GET currently
      setUrl(url);
   }

   public void onBrowserEvent(Event event) {
      if (DOM.eventGetType(event) == Event.ONLOAD) {
         unsinkEvents(Event.ONLOAD);
         DOM.eventCancelBubble(event, true);
         RootPanel.get().remove(this);
      } else {
         super.onBrowserEvent(event);
      }
   }
}

In order to populate the action with URL, GetRequestBuilder generates a GET URL request based on the base Url, target Url, and request params. Here is the breakdown of the GET parameters:

Base Url will be fixed and it will almost always be GWT.getModuleBaseURL().
Target Url is also fixed and will always be exporter.
There are few reserved parameters that are required to be passed. They are:
1. serviceName (This is used by server side plumbing code)
2. exportAs (This is used by server side plumbing code)
Add remaining parameters as per your business case (Remember its GET request, so it does have length limitation).

public class GetRequestBuilder {
	private static final String QUESTIONMARK = "?";
	private static final String EQUAL_TO = "=";
	private static final String PARAMETER_DELIMITER = "&";
	
	private Map<String, String> params = new LinkedHashMap<String, String>();
	private String baseUrl;
	private String targetUrl;
	
	public GetRequestBuilder withBaseUrl(String baseUrl) {
		this.baseUrl = baseUrl;
		return this;
	}

	public GetRequestBuilder withTargetUrl(String targetUrl) {
		this.targetUrl = targetUrl;
		return this;
	}
	
	public GetRequestBuilder havingParameterWithValue(String name, String value) {
		if(value != null){
			params.put(name, value);
		}
		return this;
	}

	public String toEncodedUrl() {
		StringBuilder url = new StringBuilder();
		if(baseUrl != null) {
			url.append(baseUrl);
		}
		if(targetUrl != null) {
			url.append(targetUrl);
		}
		if(!params.entrySet().isEmpty()) {
			url.append(QUESTIONMARK);
		}
		int size = params.size();
		int count = 0;
		for (Map.Entry<String, String> requestParameter : params.entrySet()) {
			url.append(requestParameter.getKey());
			url.append(EQUAL_TO);
			url.append(requestParameter.getValue());
			if (count < size - 1) {
				url.append(PARAMETER_DELIMITER);
				count++;
			}
		}
		
		return URL.encode(url.toString());
	}
}

Finally, here is the client code in action using the above abstractions:

Button csvExport = new Button();
AbstractImagePrototype csvIcon = IconHelper.createStyle("csv");
csvExport.setIcon(csvIcon);
csvExport.setToolTip("Download CSV");
final DownloadCsvAction downloadCsvAction = new DownloadCsvAction();
String encodedUrl = 
	new GetRequestBuilder()
		.withBaseUrl(GWT.getModuleBaseURL())
		.withTargetUrl("exporter")
		.havingParameterWithValue("exportAs", "csv")
		.havingParameterWithValue("serviceName", "searchResultsExporterService")
		.havingParameterWithValue("paramOne", "someValue")
		.havingParameterWithValue("paramTwo", "someOtherValue")
		.toEncodedUrl();

downloadCsvAction.setEncodedUrl(encodedUrl));
csvExport.addSelectionListener(new SelectionListener<ButtonEvent>() {
	public void componentSelected(ButtonEvent ce) {
		downloadCsvAction.execute();
	}
});

B. The Server-Side Plumbing:

ExporterServlet is the front-ending servlet for all export requests from Web. Look at web.xml for the settings/wiring of this servlet.

	<servlet>
		<servlet-name>exporter</servlet-name>
		<servlet-class>com.company.product.web.servlets.ExporterServlet</servlet-class>
		<load-on-startup>2</load-on-startup>
	</servlet>
	
	<servlet-mapping>
		<servlet-name>exporter</servlet-name>
		<url-pattern>/application/exporter</url-pattern>
	</servlet-mapping>

ExporterServlet converts the reserved parameters for you already. In the service() method, you will want to add in section of code to forward the request to a particular exporter service that is represented by the serviceName parameter in the request.

public class ExporterServlet extends HttpServlet {

	private ApplicationContext spring;
	private SearchResultsExporterService searchResultsExporterService;

	public void init(ServletConfig servletConfig) throws ServletException {
		spring = WebApplicationContextUtils.getWebApplicationContext(servletConfig.getServletContext());
		searchResultsExporterService = (SearchResultsExporterService) spring.getBean("searchResultsExporterService");
	}

	protected void service(HttpServletRequest httpRequest, HttpServletResponse httpResponse) throws ServletException, IOException {
		String serviceName = httpRequest.getParameter("serviceName");
		String exportAs = httpRequest.getParameter("exportAs").toUpperCase();
		ExportAs format = ExportAs.valueOf(exportAs);

		if("searchResultsExporterService".equals(serviceName)) {
			exportSearchResults(httpRequest, httpResponse, format);
			return;
		}
		httpResponse.setStatus(HttpServletResponse.SC_FORBIDDEN);
	}

	private void exportSearchResults(HttpServletRequest httpRequest, HttpServletResponse httpResponse, ExportAs format) throws IOException {
		SearchCriteria criteria = new SearchCriteria();
		criteria.setParamOne(httpRequest.getParameter("paramOne"));
		criteria.setParamTwo(httpRequest.getParameter("paramTwo"));
		searchResultsExporterService.export(httpResponse, format, criteria);
	}
}

Here is the ExportAs enumeration.

public enum ExportAs {
	CSV, EXCEL
}

ExporterServlet already has Spring application context, all you have to do is spring.getBean(serviceName) to get handle to your spring configured service. For example, look at SearchResultsExporterService and DefaultSearchResultsExporterService as reference implementation. Here, SearchResultsExporterService is a facade over SearchResultsService with additional responsibility of exporting search results. In short, the exporter service will use delegation to appropriate type of Exporter (CsvExporter, ExcelExporter) as the case may be. For additional parameters that your service method needs, you will have to reconstruct the objects on the server-side by hand if your service requires it (as this is case based, you do this by hand)...take a look at the SearchCriteria construction.

public interface SearchResultsExporterService {

	void export(HttpServletResponse httpResponse, ExportAs format, SearchCriteria criteria) throws IOException;

}


public class DefaultSearchResultsExporterService implements SearchResultsExporterService {

	private static final String CONTENT_DISPOSITION = "Content-Disposition";
	private static final String ATTACHMENT_FILENAME = "attachment; filename=";
	private static final String filename = "SearchResults";
	private final SearchResultsService searchResultsService;
	
	public DefaultSearchResultsExporterService(SearchResultsService searchResultsService) {
		this.searchResultsService = searchResultsService;
	}

	public void export(HttpServletResponse httpResponse, ExportAs format, SearchCriteria criteria) throws IOException {
		setContentType(httpResponse, exporter);
		setContentDisposition(httpResponse, exporter, filename);
		exporter = getExporter(format);

		OutputStream outputStream = httpResponse.getOutputStream();
		exporter.exportHeader(outputStream, getHeader());
		try {
			//Invoke the actual service and loop through the results
			for (Result result : searchResultsservice.getResults()) {
				exporter.exportRow(outputStream, resultAsRow(result));
			}
		} finally {
			exporter.flush(outputStream);
		}
	}

	private Exporter getExporter(ExportAs exportAs) {
		switch (exportAs){
			case CSV: 
				exporter = new CsvExporter();
				break;
			case EXCEL:
				exporter = new ExcelExporter();
				break;
			default:
				exporter = new CsvExporter();
		}
	}

	private void setContentType(HttpServletResponse httpResponse, Exporter exporter) {
		httpResponse.setContentType(exporter.contentType());
	}

	private void setContentDisposition(HttpServletResponse httpResponse, Exporter exporter, String filename) {
		httpResponse.setHeader(CONTENT_DISPOSITION, ATTACHMENT_FILENAME + filename + exporter.fileExtension());
	}
	
	private void setCharacterSet(HttpServletResponse httpResponse) {
		httpResponse.setCharacterEncoding("UTF-16");		
	}
	
}

Finally here is the exporter interface and a reference CSVExporter Reference implementation.

public interface Exporter {
	
	String contentType();

	String fileExtension();

	void exportHeader(OutputStream outputStream, List header) throws IOException;
	
	void exportRow(OutputStream outputStream, List row) throws IOException;
	
	void flush(OutputStream outputStream) throws IOException;
	
}

public class CsvExporter implements Exporter {

	private static final String COMMA = ",";
	private static final String NEWLINE = System.getProperty("line.separator");
	private static final String QUOTE = "\"";
	private String charset = "utf-8";

	public CsvExporter() {
	}
	
	public void setCharset(String charset) {
		this.charset = charset;
	}

	public String fileExtension() {
		return ".csv";
	}
	
	public String contentType() {
		return "text/csv";
	}

	public void exportHeader(OutputStream outputStream, List<String> header) throws IOException {
		writeRow(outputStream, header);
	}

	public void exportRow(OutputStream outputStream, List<String> row) throws IOException {
		writeRow(outputStream, row);
	}
	
	private void writeRow(OutputStream outputStream, List<String> row) throws IOException {
		int columns = row.size();
		for(int index = 0; index < columns; index++) {
			String data = row.get(index);
			if(data.contains(COMMA)) {
				write(outputStream, escape(data));
			} else {
				write(outputStream, data);
			}
			if (index < columns - 1) {
				write(outputStream, COMMA);
			} else {
				write(outputStream, NEWLINE);
			}
		}
	}

	private void write(OutputStream outputStream, String data) throws IOException {
		outputStream.write(data.getBytes(Charset.forName(charset)));
	}

	private String escape(String data) {
		return QUOTE + data + QUOTE;
	}

	public void flush(OutputStream outputStream) throws IOException {
	}
}

So that completes the entire design description. Now, what can impact this design?

Large number of parameters that GET cannot handle, at that point in time, we need to change the HiddenIFrame implementation to do a POST via a form...right now, my project does not need it and I am following YAGNI approach (You Ain't Gonna Need It) taking a minimalist approach.
Need to take care of Session Timeout.
Right now as it stands, the its fixed url (and open - no authentication required), unauthorized users will be able to download.

First point is a scalability thing, whereas the last two points would be applicable in general to any servlet.

Dual licensing has a bad influence on MySQL future (more generally, on open source too)

Dominique De Vito — Tue, 24 Nov 2009 05:55:45 -0500

I have read recently two French articles here and here about MySQL, that are, Michael Widenius (Monty) interviews made during Forum PHP (November 2009). Reading these interviews about MySQL was both quite hilarious and disappointing, too.

In the first interview, Monty said he has created MariaDB, a MySQL clone (?), and he has hired all core MySQL developers, and, as he said, it proves that Oracle has only bought MySQL trademark (an empty box ?). Monty said too the current MySQL development is a shame, with no manager, no leader anymore. He added that, yes, the GPL license enables to create a fork, but making a good successful fork is not easy at all and relies on a healthy ecosystem. If it were so easy, Oracle would have forked MySQL and not bought it. That's the GPL 3 problem, he concluded. So, if Oracle purchases definitively MySQL, it would be easy to destroy it, and that's why EC (European Commission) decision is important.

In the second interview, MariaDB is presented as a MySQL branch (?), and not a fork. He said he is fighting to push EC (European Commission) for restrictions on this purchase. He gives 2 main propositions as follows: either Oracle could sell MySQL, or Oracle could open much more MySQL uses while adopting a more permissive license than GPL, that is, "a BSD or Apache license: it would show Oracle has sincere intentions".

Monty wants to have the cake and eat it too!

Well, SUN has bought MySQL and MySQL has received cash (and Monty too, I imagine) for this purchase. I imagine he was quite happy at that time to accept business rules, and a loss of control of its baby. Now, as things don't turn as he wished, he complains and asks Oracle to relicense MySQL under BSD. What a joke! Monty is somewhat hilarious when talking about MySQL...

(1) Monty complains about Oracle action, but he could have done license change himself, to release previously MySQL under BSD! So, at least, he has not been a visionary!

(2) It's too easy to want to have the cake (to keep the control of MySQL code through a fork with the addition of all rights) and eat it too (the dollars he got after SUN's purchase) !

(3) There is something he didn't say during interviews: while he could do a fork, he has not anymore the copyrights of the historic main branch and then, he is not able anymore to do dual licensing. Well, he could not sell anymore to enterprises (that is, without GPL contamination), he is not able to do (full) business; and then, he complains, while he is the main person to blame.

Conclusion !?

Well, IMHO this MySQL episode suggests that one can't rely on dual licensing (and should rely with more comfort on a RDBMS like PostgreSQL).

Indeed, dual licensed projects are not true open source projects (I am against dual licensing for years!). Well, it's all about the letter and spirit of the law. These are open source projects, they respect the letter, but IMHO they don't respect the spirit, they have not all pros/features one naturally associates with true open source projects; and they can easily turn against users.

Beyond dual licensing, this MySQL episode points the GPL flaws. RMS has sent a letter to EC to stop MySQL purchase as he wrote that Oracle purchase would stop MySQL evolution, and will cause prejudice to MySQL users. Then, he confesses (without saying it) that GPL is not able to protect open source project evolution and to make live his motto Liberty, equality, fraternity.

I have written in my post Rich Hunter and a darwinian point of view for open source license debate that "the GPL looks like often the license of those who are mavericks, pioneers who invest a new land and don't want to end up naked after having done a lot of effort, with courage. I think (but one would have to verify) it reflects somewhat a "commando spirit" of those who enter first a land where only fighting proprietary software owners are, since, maybe years." While open source developers need multiple licenses, that live and play together in an ecosystem, as written in my post, I strongly doubt dual licensing (and beyond that, GPL) is adapted to open source in a professional way/context, because dual licensing is all about lock-in, and not exactly true open source.

spring-json view 1.2.1 added to maven 2 repository

Kai Ulrich — Tue, 24 Nov 2009 03:23:00 -0500

http://spring-json.sourceforge.net/

Spring Json-View adds JavaScript Object Notation (JSON) support to
Spring-MVC. Now spring-json 1.2 is added to the maven 2 central repository :

http://repo1.maven.org/maven2

usage:

<dependency>

    <groupId>net.sf.spring-json</groupId>

    <artifactId>spring-json</artifactId>

    <version>1.2.1</version>

</dependency>

Given, When, Then and how not to do it

Perryn Fowler — Tue, 24 Nov 2009 01:04:18 -0500

The Given, When, Then format is often used when writing scenarios for automated acceptance tests. Cucumber enforces this format.

This format is popular because

it enables us to express our requirements in plain english
it forces us to express each scenario clearly in terms of interactions with the system

For example:


GIVEN a registered user 'bob'

WHEN a user navigates to the Sign In page

AND the user signs in as 'bob'

THEN the profile page for 'bob' will be displayed

There are quite a few resources about that explain Given-When-Then, but I thought I would list down a few mistakes and misunderstandings I often see when people first start trying to use it. Or at least, things that differ from the way I like to do things ;)

The GIVEN clause

The given clause sets up the initial state for the scenario we are testing.

As such, it

may interact with the system

But should not

perform interactions relevant to the scenario itself

For example, I think the following would not be an appropriate way to express the example above because the GIVEN step is performing an interaction that is part of the thing we are trying to test, instead of just set up for it.


GIVEN a registered user 'bob' has signed in 

THEN the profile page for 'bob' will be displayed

Also it

should be expressed as a pre-existing condition

But should not

be expressed like an action

For example, I think the following would not be an appropriate way to express the example above because the GIVEN step sounds like it is an action rather than an existing condition


GIVEN a user registers as 'bob'

WHEN a user navigates to the Sign In page

AND the user signs in as 'bob'

THEN the profile page for 'bob' will be displayed

The WHEN clause

The when clause describes the things that the user (or some other actor) does to the system.

As such, it

should describe what the user does

But should not

describe things that the system does

For example, I think the second WHEN clause below is an inappropriate use of WHEN since it describes something the system does.


GIVEN a registered user 'bob'

WHEN a user navigates to the Sign In page

AND the user signs in as 'bob'

WHEN the profile page for 'bob' is displayed

THEN the username 'bob' will be displayed

The THEN clause

The then clause describes the things that the system is expected to do. ( in response to something done in a when clause)

As such, it

should describe what the system should do

But should not

describe things that the user does

For example, I think the following contains innapropriate use of THEN since it is being used to describe things that the user does. Although this still presents a coherent narrative, it blurs the distinction between what the user does and what we expect the system to do in response.


GIVEN a registered user 'bob'

THEN a user navigates to the Sign In page

THEN the user signs in as 'bob'

THEN the profile page for 'bob' is displayed

Online text to speech application Japplis Speech 1.2 has been released

Anthony Goubard — Tue, 24 Nov 2009 01:00:00 -0500

I've just released Japplis Speech 1.2.

Japplis Speech is a text to speech application, that includes the possibility to read the text while you're typing it.

In this release the start-up has been greatly improved.
This release also includes Japplis Speech + which is the similar to Japplis Speech. Japplis Speech + has a better voice quaility but a slower start-up time.

XenonDataGrid M4.0, Nelson Framework WIP

Peter Pilgrim — Mon, 23 Nov 2009 18:04:54 -0500

XenonDataGrid M4.0, Nelson Framework WIP

Hi All

I am very happy make the release Milestone 4.0 release of the Nelson Core JavaFX Framework and the Xenon Data Grid Component. You can find the download nelson-core-1.0-M4.jar on Xenonique. I have already uploaded the PDF slides to my talk on XenonDataGrid at Devoxx 2009.

The Devoxx Master Launcher (JNLP)

Release Notes

These are release notes for Nelson Core JavaFX framework.
http://www.jroller.com/peter_pilgrim/entry/the_nelson_framework

Milestone 4
=============

The ``XenonDataGrid'' data grid UI component is the fundamental and paramount change in this release.

The Key Changes

Support for more FX Types instead of Strin now includes Boolean, Character, Byte, Short, Integer, Long, Float and Double.

``DynamicGridCellRenderer'' is a new renderer with a ``Painter'' architecture to support different FXType.

``BooleanGridCellPainter'' is a painter for rendering Boolean cells.

``BooleanEditorCellPainter'' is a editor component to changing Boolean cells.

``DecimalGridCellPainter'' is a painter for rendering decimal types, namely Floats and Doubles.

``IntegralGridCellPainter'' is a painter dedicated for rendering integer types, namely Byte, Short, Integer and Long

``TextGridCellPainter'' is a renderer for rendering String as before.

``RegisterEditorTableModelVariant'' - a mixin for table model to support editor renderor associated an FXType.

``LifecycleManager'' is a store for managing dynamic painters, associated with DynamicGridCellRenderer

A new plug-in keyboard selection strategy. The default one is called ``DefaultNavigationStrategy''

A new package ``com.xenonsoft.nelson.scene.layout.grid.conversion'

A new plug-in type conversion strategy. The default one is called ``StringConverter''

JIRA ISSUES
============

http://kenai.com/jira/browse/NELSON-18

    XDG has scroll wheel support
    XDG has plug-in keyboard navigation *FIXED*

http://kenai.com/jira/browse/NELSON-14

    Users need to be able to display application data in many types in JavaFX.
    Consequently, the XDG needs data adaptors, and renderers for types other java.lang.String. *INCOMPLETE*
    So this M4 release features an BooleanGridCellPainter, IntegralGridCellPainter, DecimalGridCellPainter etc

http://kenai.com/jira/browse/NELSON-20

    Introduce Keyboard Navigation Strategy in XDG *FIXED*

http://kenai.com/jira/browse/NELSON-12

    Redesign and refactor reordering layer API *FIXED*

http://kenai.com/jira/browse/NELSON-10

    Improve JavaFXDoc to a higher level *FIXED*

http://kenai.com/jira/browse/NELSON-19
    Graphic Niggles *INCOMPLETE*

http://kenai.com/jira/browse/NELSON-11

    Reordering of Rows and Columns is broken *FIXED*

http://kenai.com/jira/browse/NELSON-13
    Refactor by name XDG scroll properties *FIXED*

http://kenai.com/jira/browse/NELSON-7

    DataGrid should allow the application developer to listen to important events *INCOMPLETE*
    M4 includes a ``ScrollEvent'' type.

http://kenai.com/jira/browse/NELSON-17

    XDG needs skinnable subcomponents *OPEN*

http://kenai.com/jira/browse/NELSON-16

    Dynamic creation of rendering. *FIXED*
    See ``DynamicGridCellRenderer'' and the new painter infrastructure

http://kenai.com/jira/browse/NELSON-15

    Unify render layer and table model data structures? *CLOSED*
    Based on discussions at Devoxx 2009, where an audience participant asked about filtering of
    the data model, I feel this is the wrong approach. This issue is closed

Peter Pilgrim
Monday, 23 November 2009

My interview with developerWorks

Hazem Ahmed Saleh — Mon, 23 Nov 2009 16:56:41 -0500

(Valerie Skinner - a developerWorks team member) invited me for an interview about my open source experience.

Here is the interview script:
https://www.ibm.com/developerworks/mydeveloperworks/blogs/yinmeetsyang/entry/interview_with_hazem_saleh12?lang=en_us

I wish it can be useful.

Desperate Binding Module in Swing

Mario García — Mon, 23 Nov 2009 12:14:51 -0500

Buff, If I knew how much I was going to suffer doing a binding module... aaarrggg!!

It's really difficult to establish a basement for building something scalable or even maintainable. I've spent a whole week and I think it's enough for me, tomorrow I'm going to see if I come to an end or I leave it.

I took a look at beansbindings and jgoodies binding as a start, but at the beginning was like reading chinese for me. Swing is a nightmare for doing that sort of things.

The only conclusion I could come to was that I had to do a part for binding properties between beans and ui components, and another part for binding lists with UI components.

jgoodies binding: https://binding.dev.java.net/
beansbinding: https://beansbinding.dev.java.net

Session Handling in GWT

Dhaval Dalal — Mon, 23 Nov 2009 07:40:31 -0500

On my current GWT project, I needed to re-direct the user to the Login Dialog box upon session timeout on the server. In traditional web applications, it can be done either by taking a Filter-based approach or a inheriting from a common Controller Servlet; with GWT, it gets a little different...especially on the client-side...and depending on the frameworks that you use, you may need to do some additional work other than the server-side. On my project, I chose the Spring, Hibernate, Gilead and GWT-SL as a stack of technologies that will allow me to use the DDD approach so that I do not have to code a DTO layer, refer to my earlier post for tech frameworks stack.

First of all, some context on GWT method exceptions. In GWT, call to an asynchronous method throws an exception or it returns the Object that you want to do something with on the client-side. So, the strategy that I adopted for session handling is to throw an Exception upon Session-Timeout and let each response handler in the application deal with that exception. But this means that each response handler has to deal with Session-Timeout related exception....this calls for creating a generic mechanism for handling session timeout for all reponse handlers within the application. Hence, I came up with ApplicationResponseHandler, from which all the other response handlers will derive from. ApplicationResponse handler will take care of client-side handling of session timeout and/or other generic stuff. In the code below, when I receive message keys pertaining to session timeout, or not-logged-in or logout error, I dispatch a Logout event using the GWT's event Dispatcher. But, if the message keys are not the ones that ApplicationResponseHandler is not interested in handling, it calls the uponFailure(), and so with uponSuccess().

public abstract class ApplicationResponseHandler<T> implements AsyncCallback<T> {

	public ApplicationResponseHandler() {
	}
	
	public final void onFailure(Throwable caught) {
		String messageKey = caught.getMessage();
		if (
			(GatewayMessageKeys.SESSION_TIMEOUT.equals(messageKey)) ||
			(GatewayMessageKeys.NOT_LOGGED_IN.equals(messageKey)) ||
			(GatewayMessageKeys.LOGOUT_ERROR.equals(messageKey))) {
			dispatchLogoutEvent();
			return;
		}
		uponFailure(caught);
	}

	protected void dispatchLogoutEvent() {
		Dispatcher.get().dispatch(GatewayEvents.Logout);
	}
	
	public final void onSuccess(T result) {
		uponSuccess(result);
	};
	
	public abstract void uponSuccess(T result);
	public abstract void uponFailure(Throwable problem);
}

Here are the GatewayMessage keys, packed in GatewayMessageKeys interface

public final class GatewayMessageKeys {
	private GatewayMessageKeys() {
	}
	public static final String INCORRECT_CREDENTIALS = "incorrectCredentials"; 
	public static final String ACCOUNT_DOES_NOT_EXIST = "accountDoesNotExist";
	public static final String SERVICE_UNAVAILABLE = "serviceUnavailable";
	
	public static final String NOT_LOGGED_IN = "notLoggedIn";
	public static final String LOGOUT_SUCCESSFUL = "logoutSuccessful";
	public static final String LOGOUT_ERROR = "logoutError";
	public static final String SESSION_TIMEOUT = "sessionTimeout";
}

Having taken care of the client-side plumbing, lets move on to the server-side. Further, the GWT's RPC encoding and processing logic examines interfaces for declared exceptions and if your method encounters an exception that is NOT declared in the throws clause of the RPC interface, then GWT throws an UnexpectedException instead to the client and you will see..."Call failed on server...See server log for details". This implies that GWT demands that server-side RPC method needs to throw a Checked Exception. So, I came up with this class called ApplicationException, from which all our other Exception subclasses will inherit from.

/**
 * Please do not add Throwable cause constructors, because we do 
 * not want to reveal the stack trace to the client...obvious security 
 * risk! In your exception class, if you still need to provide a 
 * throwable cause constructor (due to some third party library 
 * dependency or due to any other reason), then make a call to 
 * super(message) constructor of this class.
 */
public class ApplicationException extends Exception {

	public ApplicationException() {
		super();
	}

	public ApplicationException(String message) {
		super(message);
	}
}

Below is the GatewayService that is called when the user logs-in to and logs-out of the application.

@RemoteServiceRelativePath("services/gatewayService")
public interface GatewayService extends RemoteService {
	User login(String userName, String password) throws LoginFailure;
	public String logout(String uid) throws LogoutFailure;
}

In the DefaultGatewayService implementation, as I am using the GWT-SL, it helps me export regular Spring-configured services as GWT-RPC services, the only problem is that these services are not HttpServletRequest/Response aware. Hence, I make them HttpServletRequest/Response aware by injecting HttpContext when the service is created by Spring. Apart from that, I inject the authenticator used by the login() method to authenticate the user.

public class DefaultGatewayService implements GatewayService {
	
	public static final String TICKET = "__APPLICATION_TICKET__";
	private final Authenticator authenticator;
	private final HttpContext httpContext;

	public DefaultGatewayService(Authenticator authenticator, HttpContext httpContext) {
		this.authenticator = authenticator;
		this.httpContext = httpContext;
	}
	
	@Transactional(readOnly = true)
	public User login(String uid, String password) throws LoginFailure {
		HttpSession session = getHttpServletRequest().getSession(false);
		if(exists(session)) {
			session.invalidate();
		}
		User user = authenticator.authenticate(uid, password);
		createNewSession(user);
		return user;
	}

	private void createNewSession(User user) {
		HttpSession session = getHttpServletRequest().getSession();
		session.setAttribute(USER, user.getUid());
	}
	
	public String logout(String uid) throws LogoutFailure {
		if (doesNotExists(uid)) {
			throw new LogoutFailure(GatewayMessageKeys.NOT_LOGGED_IN);
		}
		
		HttpServletRequest httpServletRequest = getHttpServletRequest();
		HttpSession session = httpServletRequest.getSession(false);
		String userIdInSession = (String) session.getAttribute(USER);
		if(uid.equals(userIdInSession)) {
			session.setAttribute(USER, null);
			logger.info(GatewayMessageKeys.LOGOUT_SUCCESSFUL + " For User: " + uid);
		} else {
			logger.error("User " + uid + "Not in HttpSession");
		}
		session.invalidate();
		return GatewayMessageKeys.LOGOUT_SUCCESSFUL;
	}

	private String getApplicationTicketFromCookie() {
		HttpServletRequest httpRequest = getHttpServletRequest();
		Cookie[] cookies = httpRequest.getCookies();
		for (Cookie cookie : cookies) {
			if(TICKET.equals(cookie.getName())) {
				return cookie.getValue();
			}
		}
		return null;
	}
	
	private boolean doesNotExists(String uid) {
		return uid == null || uid == "";
	}

	protected HttpServletRequest getHttpServletRequest() {
		return httpContext.getHttpServletRequest();
	}
}

Here is the HttpContext, that uses a simple ThreadLocal based implementation.

public interface HttpContext {
	
	public void setHttpServletRequest(HttpServletRequest request);
	
	public HttpServletRequest getHttpServletRequest();
	
	public void setHttpServletResponse(HttpServletResponse response);
	
	public HttpServletResponse getHttpServletResponse();

}

// Implementation
public class ApplicationHttpContext implements HttpContext {
	
	private static ThreadLocal<HttpServletRequest> requestThreadLocal = new ThreadLocal<HttpServletRequest>();
	
	private static ThreadLocal<HttpServletResponse> responseThreadLocal = new ThreadLocal<HttpServletResponse>();

	@Override
	public HttpServletRequest getHttpServletRequest() {
		return requestThreadLocal.get();
	}

	@Override
	public HttpServletResponse getHttpServletResponse() {
		return responseThreadLocal.get();
	}

	@Override
	public void setHttpServletRequest(HttpServletRequest request) {
		requestThreadLocal.set(request);
	}

	@Override
	public void setHttpServletResponse(HttpServletResponse response) {
		responseThreadLocal.set(response);
	}
}

The next most interesting thing, is the ApplicationGWTRPCServiceExporter which would be used by all the Spring managed services to wrap themselves in. It is in this interceptor where session timeout validation is performed for all calls made to any of the services within the system. Here are the steps that happen in the invokeMethodOnService() method:

Inject HttpContext
Check whether a session exists or not:
- If the session does not exist:
  - If the incoming service all is that of login() method, then allow the user to login and return.
  - Else use reflection to examine the interface method called and use the declared exception of that method to throw it to the caller with message GatewayMessageKeys.SESSION_TIMEOUT.
- If session exists: Determine whether user is present in the session:
  - If user is in session, allow the service call
  - If user is not in session, wrap in target method exception and throw it and thus don't allow the service call

public class ApplicationGWTRPCServiceExporter extends HB4GWTRPCServiceExporter {
	
	private final HttpContext httpContext;
	private static final String LOGIN_METHOD = "login";
	
	public ApplicationGWTRPCServiceExporter(HttpContext httpContext, UserRepository userRepository) {
		this.httpContext = httpContext;
	}

	@Override
	public String invokeMethodOnService(Object service, Method targetMethod, Object[] targetParameters, RPCRequest rpcRequest) throws Exception {
		HttpServletRequest request = getHttpRequest();
		HttpServletResponse response = getHttpResponse();
		
		injectHttpContext(request, response);
		HttpSession session = request.getSession(false);
		if (doesNotExist(session)) {
			if (targetMethod.getName().equals(LOGIN_METHOD)) {
				return super.invokeMethodOnService(service, targetMethod, targetParameters, rpcRequest);
			}
			logger.info("HttpSession Timedout");
			InvocationTargetException invocationException = wrapInTargetMethodException(targetMethod, GatewayMessageKeys.SESSION_TIMEOUT);
			return handleInvocationTargetException(invocationException, service, targetMethod, rpcRequest);
		}
		if (userNotInSession(session)) {
			logger.info("User not in existing HttpSession..invalidating session");
			session.invalidate();
			InvocationTargetException invocationException = wrapInTargetMethodException(targetMethod, GatewayMessageKeys.NOT_LOGGED_IN);
			return handleInvocationTargetException(invocationException, service, targetMethod, rpcRequest);
		}
		logger.debug("User in existing HttpSession...allowing service call");
		return super.invokeMethodOnService(service, targetMethod, targetParameters, rpcRequest);
	}

	private void injectHttpContext(HttpServletRequest request, HttpServletResponse response) {
		httpContext.setHttpServletRequest(request);
		httpContext.setHttpServletResponse(response);
	}

	private InvocationTargetException wrapInTargetMethodException(Method targetMethod, String messageKey) throws Exception {
		Class[] exceptionTypes = targetMethod.getExceptionTypes();
		if(exceptionTypes.length > 0) {
			Constructor constructor = exceptionTypes[0].getConstructor(String.class);
			Exception newExceptionInstance = (Exception) constructor.newInstance(messageKey);
			return new InvocationTargetException(newExceptionInstance);
		}
		return new InvocationTargetException(new ApplicationException("Make sure your Service Method throws subclass of ApplicationException!!"));
	}

	protected HttpServletRequest getHttpRequest() {
		return getThreadLocalRequest();
	}
	
	protected HttpServletResponse getHttpResponse() {
		return getThreadLocalResponse();
	}
}

PrimeFaces 1.0.0.RC Released

Cagatay Civici — Mon, 23 Nov 2009 04:57:12 -0500

http://cagataycivici.wordpress.com/2009/11/23/primefaces-1-0-0-rc-is-released/

Thinking of systems

Rickard Öberg — Mon, 23 Nov 2009 00:10:55 -0500

A couple of weeks ago I, Trygve Reenskaug (inventor of the MVC pattern) and Jim Coplien did a track at the Oredev conference about DCI (Data, Context, Interaction), which is a new way of thinking about object-oriented software development. Trygve's presentation did a good job at analyzing the progression from the procedural programming, where code could be read and understood, to todays object-oriented paradigm in which descriptions of interactions and algorithms are spread out in a multitude of so-called "objects", thereby making it impossible to get an understanding of how the overall system works, and what the interactions between objects are. DCI is an attempt to reconnect with the procedural programming success, where it was possible to read a procedure and figure out what the software does. By bringing this concept, that of systems and a sense holistic views, back into software development we might be able to avert the quality crisis that our industry is currently in.

After having done this presentation, I also realized that software development is not the only field of human activity which suffers from this general issue. Apart from studying software development I am also looking into management theory, healthcare, and psychopathological influences on societal levels (aka political ponerology). What I can see now, with software development as an example of the general pattern, is that all these fields, in their popular western form, suffer from the same issue: the inability to look at the problem from a systems point of view, and instead focusing on the individual parts, thereby introducing suboptimizations and harming flow that decrease quality and increases cost.

In management theory we have the notion of "economies of scale", where service is seen as a form of production where workers are given standards and highly detailed processes to be adhered to (and which were not created by the workers themselves). The idea is that by having these standards, and targets to measure success with, we can reach new levels of productivity and efficiency, which are impossible to reach otherwise. These notions are sometimes implicit in the management of a company, and sometimes they are explicitly expounded through implementation of things like ISO 9000. This idea has now been shown to be false, even fatally so, and is slowly being replaced with a more holistic view, that of systems thinking, which talks of "economies of flow" instead, and where knowledge and understanding replaces guessing and predicting. Here is one example outlining this.

In the healthcare sector we are currently seeing a failure on a monumental scale, as the western methods of understanding, diagnosing and treating disease based on the "fix the parts"-idea are not working. We are spending monumental amounts of money on healthcare and medicine, and which don't solve the problem, introduce new problems through sideeffects, and which ultimately only works to create an even sicker population, which benefit the "big pharma" that is supposed to help us deal with it in the first place. The healthcare issues are then further compounded by the use of flawed management theory, as outlined above, which makes it even more inefficient and useless. Those who work in hospitals are often trying to desperately workaround the system to help patients, but ultimately they are only the 5% of the puzzle, with 95% of the outcome being ruled by the system itself, flawed as it is.

In contrast, holistic medicinal practices such as TCM (Traditional Chinese Medicine) provides a way of looking at the human body as a system, understanding the parts as being related to each other, and has uninvasive methods of treatment, largely without side-effects, and at a cost that is only a fraction of what the western "modern" method would be. TCM is slowly being adapted by western institutions, but it has to be done cautiosly as it is still officially considered "alternative" and unproven. Whether TCM works or not isn't really the issue. The issue is that its very underlying idea, that of the human body being a system whose parts interact symbiotically, threatens the ideology that western medicine is based on, and as any weakly founded religion would do, such threats must be dealt with without remorse. Questioning dogma is simply not an option.

Finally, when it comes to understanding pathology of the mind, and the effect that it has on our society, the western research so far has focused on the diagnosis and treatment of individuals, without looking at the bigger picture. Thus the popular idea of psychopaths, and other pathological disorders, is still in most peoples mind limited to the extreme examples provided by Hollywood and flashing headlines, where extreme psychopaths go on killing sprees and whatnot. This, however, we now know is not an accurate reflection of the impact that people with pathological mental disorders have on society. Through the study of political ponerology one can get a glimpse of the fact that not only are these mental disorders more common than one would think, they also interact in such a way as to boost each other. A psychopath with a devious plan might manipulate a paranoid schizophrenic to further it, which in turn causes people with narcissistic wounding to become devotees and followers, thereby creating a chain of delusion which ultimately infects entire social groups, societies, and eventually nations. We have many examples of this in our contemporary history, and there is no reason to believe that this will not happen again, as the only vaccine is knowledge, and knowledge is sparse. By studying pathology and ponerology it also becomes possible to understand the impact that it has had on the previous two systems, that of management and healthcare, and as noted, healthcare in itself is afflicted by the delusions of current management thinking as well.

In short, not only do we have to start thinking in terms of systems with regard to individual aspects of life, such as healthcare, we must also consider how these systems interact, pathologically, on an even larger scale. Only then does it become possible to understand the monumental amount of waste and failure that we have created, and which is made possible by remaining in the dark as to the underlying causes.

Doom and gloom? Yes, indeed, the picture is pretty much pitch black as it is. But as John Seddon points out, there is no way to create change without first studying the system as it is, in its current incarnation. The good news is that the interconnectedness works both ways. If we collectively deal with the root cause of all these issues, which is the pathological influence of various mental disorders, then the other affected systems will benefit from it, and when you have systems interacting with systems in a positive way you get exponential improvement as a result: if management theory accepts and corrects itself based on an understanding of pathological thinking, it will help the healthcare system, which in turn will give them a way to get a more holistic way of looking at their work, which can improve the results of treatment, which will improve everyones lives, which... and so on, you get the idea. This should be the main concern of people wanting to make a real difference in todays world, as most of anything else will be to be cutting the leaves of a tree, rather than its roots. You are, as western medicine is focused on, treating a symptom rather than the true cause. Treating the true problem will clear out the symptoms that it caused, and in a way that is much more effective as you can be sure that the symptoms will not be coming back anytime soon.

Coming back to software development, which was the initial cause of this realization of mine, it is now clear to me that if we do not accept the conclusions that Trygve put forward, and which are reflected in so many other forms of human activity, there is no chance of creating software in a way that the code becomes readable, understandable and maintainable. We cannot continue to focus on the parts, the objects, without also taking into consideration the contexts and interactions that these objects have. We need a holistic way of thinking about systems.

The question is: can we afford not to do this? Can we allow ourselves to continue using bad practices, which lead to more low-quality code and unmaintainable software?

More detail on Closures in JDK 7

Stephen Colebourne — Sun, 22 Nov 2009 21:57:06 -0500

This blog goes into a little more detail about the closures announcement at Devoxx and subsequent information that has become apparent.

Closures in JDK 7

At Devoxx 2009, Mark Reinhold from Sun announced that it was time for closures in Java. This was a big surprise to everyone, and there was a bit of a vacuum as to what was announced.

Firstly, Sun, via Mark, have chosen to accept the basic case for including closures in Java. By doing so, the debate now changes from whether to go ahead, to how to proceed. This is an important step.

Secondly, what did Mark consider to be in and what out? Well, he indicated that non-local returns and the control-invocation statement were out of scope. There was also some indication that access to non-final variables may be out of scope (this is mainly because it raises nasty multi-threading Java Memory Model issues with local variables).

In terms of what was included, Mark indicated that extension methods would be considered. This would be necessary to provide meaningful closure style APIs since the existing Java collection APIs cannot be altered. The result of what was in was being called "simple closures".

Finally, Mark offered up a possible syntax. The syntax he showed was very close to FCM:

  // function expressions
  #(int i, String s) {
    System.println.out(s);
    return i + str.length();
  }

  // function expressions
  #(int i, String s) (i + str.length())
  
  // function types
  #int(int, String)

As such, its easy to say that Sun has "chosen the FCM proposal". However, with all language changes, we have to look at the semantics, not the syntax!

The other session at Devoxx was the late night BOF session. I didn't attend, however according to Reinier Zwitserloot, Mark indicated that Exception transparancy might not be essential to the final proposal.

According to Reinier, Mark also said "It is not an endorsement of FCM. He was very specific about that." I'd like to consider that in a little more detail (below).

The final twist was when a new proposal by Neal Gafter was launched which I'm referring to as the CFJ proposal. After some initial confusion, it became clear that this was written 2 weeks before Devoxx, and that Neal had discussed it primarily with James Gosling on the basis of it being a "compromise proposal". Neal has also stated that he didn't speak to Mark directly before Devoxx (and nor did I).

There are a number of elements that have come together in the various proposals:

	CICE	BGGA 0.5	FCM 0.5	CFJ 0.6a	Devoxx announcement
Literals for reflection	-	-	Yes	-	No info
Method references	-	-	Yes	Yes	No info
Closures assignable to single method interface	Yes	Yes	Yes	Yes	No info
Closures independent of single method interface	-	Yes	Yes	Yes	Yes
Access non-final local variables	Yes	Yes	Yes	Yes	Maybe not
Keyword 'this' binds to enclosing class	-	Yes	Yes	Yes	Probably yes
Local 'return' (binds to closure)	Yes	-	Yes	Yes	Yes
Non-local 'return' (binds to enclosing method)	-	Yes	-	-	No
Alternative 'return' binding (Last-line-no-semicolon)	-	Yes	-	-	No
Exception transparancy	-	Yes	Yes	Yes	Maybe not
Function types	-	Yes	Yes	Yes	Yes
Library based Control Structure	-	Yes	-	-	No
Proposed closure syntax	Name(args) {block}	{args => block;expr}	#(args) {block}	#(args) {block} #(args) expr	#(args) {block} #(args) (expr)

A table never captures the full detail of any proposal. However, I hope that I've demonstrated some key points.

Firstly, the table shows how the CFJ is worthy of a new name (from BGGA) as it treats the problem space differently by avoiding non-local returns and control invocation. Neal Gafter is also the only author of the CFJ proposal, unlike BGGA.

Secondly, it should be clear that at the high level, the CFJ and FCM proposals are similar. But in many respects, this is also a result of what would naturally occur when the non-local returns and control invocation is removed from BGGA.

Finally, it should be clear that it is not certain that the CFJ proposal meets the aims that Mark announced at Devoxx ("simple closures"). There simply isn't enough hard information to make that judgement.

One question I've seen on a few tweets and blog posts is whether Mark and Sun picked the BGGA or FCM proposal. Well, given what Mark said in the BOF (via Reinier), the answer is that neither was "picked" and that he'd like to see a new form of "simple closures" created. However, it should also be clear that the choices announced at Devoxx were certainly closer to the FCM proposal than any other proposal widely circulated at the time of the announcement.

At this point, it is critical to note that Neal Gafter adds a huge amount of technical detail to each proposal he is involved with - both BGGA and CFJ. The FCM proposal, while considerably more detailed than CICE, was never at the level necessary for full usage in the JDK. As such, I welcome the CFJ proposal as taking key points from FCM and applying the rigour from BGGA.

As of now, there has been relatively little debate on extension methods.

Summary

The key point now is to focus on how to implement closures within the overall scope laid out. This should allow the discussion to move forward considerably, and hopefully with less acrimony.

S1 Java di Universitas Gunadarma, program jTechnopreneuer dan Program jTechnopreneur 1 tahun (Cakra)

Frans Thamura — Sun, 22 Nov 2009 20:45:25 -0500

Program jTechnopreneur dimulai dengan roadshow tahun 2008 lalu di 8 kota, untuk mempromosikan gimana berwirausaha dengan Java, dan selain itu sejak 2006 saya membantu IBC (Incubator Business Center) Gunadarma, menshare pengalaman dan susah sedihnya berwirausaha di Indonesia.

jTechnopreneur 2008 Unpar Bandung

jTechnopreneur 2008 IPB Bandung

Kecapean sampe ketiduran di jTechnopreneur IPB Bogor

Sekarang telah lahir sebuah program undergraduate atau Strata 1 di Universitas Gunadarma dengan sebutan jTechnopreneur Program, ini sebenarnya extension kecil dikurikulum S1 dari Universitas Gunadarma, tetapi kalau digabung-gabung total semuanya, banyak juga yang berubah, lihat diagram dipresentasi dibawah ini, terutama yang warna biru, itu adalah program intensive Java di Gunadarma, sedangkan yang pink, masih dalam proses, terutama sistem operasi, kita inginnya mengadopsi teknologi Java on Hypervisor, jadi cloud infrastructure langsung menjalankan Java tanpa sistem operasi, sebuah teknologi virtual edition terbaru dari Java, sebagai tambahan boot sistem operasi yang umum didunia virtualization.

Selain itu kita juga memiliki program 1 tahun, kode name Cakra, untuk membuat perusahaan kecil berbasis teknologi, khususnya Java tentu saja. Walaupun dalam perjalanannya tidak 100% Java, tetapi ada Javascript sebagai default skillset untuk AJAX, dan untuk intensif aplikasi frontnya kita menciptakan project MIDAS. Apa itu Midas, tunggu blog saya berikutnya...

Nah ini dia slide apa itu jTechnopreneur C/S (Computer Science) S1 dan Meruvian Cakra.

jTechnopreneur C/S r1.1

View more presentations from Frans Thamura.

Devoxx 2009 Xenon Data Grid Presentation Slides

Peter Pilgrim — Sun, 22 Nov 2009 13:50:45 -0500

Devoxx 2009 Xenon Data Grid Presentation Slides

Above all, I strongly recommend the Devoxx conference to any Java beginner in Europe who wants to expand their mind, to get ahead and to stay ahead of the pack.

Dear Reader

Well Hello Devoxx 2009 POST conference.

Here are my presentation slides for my short talk at Devoxx 2009 on Wednesday 18th November 2009.

Here is the slide deck (PDF file).

XenonDataGrid Open Source JavaFX Table Component

Abstract

In this brief presentation, I will talk about the XenonDataGrid JavaFX component that I have been building over the Summer of 2009. The XenonDataGrid is a table component, displays data in rows and columns. It is comparable to Swing's JTable component except that XDG is purely developed in JavaFX, and therefore uses the scenegraph for rendering rather than calling directly Java 2D immediate mode API. XenonDataGrid is part of the Nelson FX project, which I open sourced on Project Kenai shortly after JavaOne 2009.

See you all next year at Devoxx 2010!

Creating (another) Firefox Theme

Wesley Hales — Sun, 22 Nov 2009 10:50:58 -0500

I started laying down ideas for a new Firefox theme a few months ago and this is what emerged. I'm not sure why I can't stay away from the darker themes. Maybe it's the richness that black (and darker colors) allows on a monitor, but I tried to stay as far away from mainstream design on this as I could. I have already coded this into a downloadable theme, but I am still working out some glitches. Then I have to let it sit in the Mozilla incubator, as I did with ANTHEM.

Speaking of ANTHEM, I'm quite surprised that it has done so well. 780k downloads and counting in 1 year. But it is all in vain if I can't "supply more blood" to this living organ (As Rob W. likes to put it.) With that said, I'm thinking about starting an open source project for these themes, because quite honestly, I don't have time to fix the bugs. Anybody wanna help? Comment with your email...

I have been a bit indecisive about the the background on the toolbar on this one. What do you think? The first one at the top, or this one...

Devoxx 2009 Digital Media Report

Peter Pilgrim — Fri, 20 Nov 2009 09:54:13 -0500

Devoxx 2009 Digital Media Report

Above all, I strongly recommend the Devoxx conference to any Java beginner in Europe who wants to expand their mind, to get ahead and to stay ahead of the pack.

Dear Reader

Well Hello Devoxx 2009 conference and it is Wednesday

First, a few words, on the conference itself. I think Devoxx is the best conference this side of the Atlantic Ocean for Java news and speakers. The technical quality of the speakers is excellent. Sun Microsystems also feels this is a great community so they will sent their top representatives like Brian Goetz, Mark Reinhold, Alex Buckley, Joe Darcy, Richard Bair, Bruno Souza and Aaron Houston. So okay even if this conference was 500 participants down from last year and the economic markets is suffering severe dislocation in many countries of the world, this Devoxx conference is undoubtedly the European standard, against which conferences have to be compare with.

[European JUG Leaders BOF 2009 with James Gosling Meeting Vimeo Player *Coming Soon*]

Photo courtesy of Stephan Janssen uploaded onto Picasa.

This year yours truly has decided not write any more daily blog reports. I think you, dearest reader, you have been getting thatmessage from myself with my AudioBoo and video drops over the past six to eight months or so.

Devoxx 2009 Interview with the Adaptavist guys

Devoxx 2009 Interview with Stephen Colebourne Opinions on JDK 7 Closures etc

Devoxx 2009 My Interview for Aaron Houston, Program Director, Outreach, Sun Microsystems

Devoxx 2009 Interview with Antonia Gonclaves, Paris JUG Leader, Java EE 6 Advocate

Devoxx 2009 Interview with Oliver Gierke, Easing JPA with Hades

Devoxx 2009 Interview with Frederick Simon, JFrog, Talking About Artifactory

UStream TV Devoxx JAVAWUG Link-Up Show

In other words, I think a daily blog is a complete waste of (my) time. Why? Because, people can get the best of external news from Twitter and professional journal blogs. However, I do think that the new digital media taking advantage of these technologies is the correct way to go. I attempted to do this on Tuesday night with a live link up with the JAVAWUG in London. Richard Gomes was hosting our very first Professional Jam #1. Antwerp's timezone is one hour ahead of time of London, and still I found out later in the day that the Internet link at Skills Matter was unavailable. It was sod's law, but I continue with my Ustream TV feed and recorded it. You can judge the results yourself of whether this helps user group members who unluckily unable to visit a conference such as Devoxx.

[UStream liveshow]

Live Streaming by Ustream.TV

It was rough and ready and the quality of the video low, but I believe this is valuable in the next decade when we will be economically and airplane challenged. In English, travel may become more restrictive and socially frown upon unless it is necessary. I can certain JUG Leaders, like Marcelo Magno from the Milan JUG, using Ustream TV to broadcast live or recorded to native speakers of his user group who do not speak English very well. Tech has it's uses and I am digressing here ...

Chet Haase and I in a photograph. This is a real proud moment. What a graphics hero Chet Haase is?

Incredible Announcements and The Vector of Progress Continues Unabated

The top items of interest were JavaFX (of course), Java EE 6, Scala and JDK 7 Changes. Additionally, I was most impressed with the high standard of operation and integration of the Adobe Flex tools. In particular, the Adobe Catalyst demonstration was outstanding. As a developer you can easily take the composition layers of a designer's Photoshop, Illustrator or Flash file, and simply select a region, and automatically convert that graphic into an ActionScript button.This was for me watching it live physically unheard of usability and productivity between developers and designers.

Tor Norbye and Stephen Chin

JavaFX started with Stephen Chin's University talk, which I thought was a light gentre introduction into JavaFX areas and capabilities. However, in the middle of this talk was a real clincher, Tor Norbye, the technical leader of authorisation tool, who demonstrated the Netbean JavaFX Rapid Application Development tool. The NetBeans 6.8 team have been very busy. The Matisse qualities of the forthcoming RAD tools for JavaFX look very impressive indeed. The ability to drag components from the palette into a design canvas, the ability edit properties of those component is simply paramount programmability. The next trick that Tor showed off was the binding, timeline and animation capabilites. Yes that is quite right, the design canvas was not a static breadboard, it actually came to life with transformation, effects and opacities changes. Best of all this produce readable JavaFX code I think. I forgot to ask Tor whether this was reversible. Can you tweak the RAD tools JavaFX code and would it still work? Hmmm.... Anyway nice, I cannot wait for NetBeans 6.8 to be released.

Juggy, the Brazilian Java User Group mascot and myself at Access, Bar Salsa.

There was a demonstration of the PRISM runtime exclusively in the last JavaFX session on Friday with Richard Bair and Jasper Potts. It was fast, fantastically fast. JavaFX 1.3 will be out on January/February 2010, I think they [Sun] are targetting the Mobile World Congress in Barcelona for this. Good luck boys, I hope you make it. PRISM is slated for next years JavaOne 2010 (or whatever they are going to call it).

Howard Lewis-Ship presenting Clojure the JVM language

I was most impressed with ScalaTest and the ability to remove boilerplate code from EasyMock and the behaviour driven tests. Bill Venners was excellent and I want to take up the suggestion that a good way way to get involved in Scala is to start writing ScalaTest. He suggested that we use our own existing Java libraries and codebase to do this. Great idea.

Java EE 6 specification and the reference implementation looks good. We are finally getting an EJB container API that we can test outside the application server. Antonio Gonclaves and Alexis Moussine-Pouchkine had a great talk. The Servlet 3 API, however, from Kevin Nielson's eyes, at least when he discussed this topic with myself, looked weakened from what was originally expected, althought it is still a step forward in progress. Java EE 6 and the JDK 7, I believe, will make an awesome combination. No longer do we need monolithic application server that were truly heavy. Instead we might looking at web server monitors based on EJB Lite containers. The EJB might be facade on a data persistence that do need no damn SQL database server.

Of course there is now new direction, not quite a change of heart, in Closures for Java. Go to Stephen Colebourne's blog for more information on the JDK 7 Closures as they now stand up.

To left is Mark Reinhold of Sun Microsystem's JDK 7 project and the Joe Darcy the technical lead of Project Coin "Small Changes" also for JDK 7. Both are participating with Brian Goetz and Alex Buckley (out of the picture) in a JDK 7 BOF at Devoxx on 18 November 2009

The best keynote of the entire conference was by Robert C. Martin. And so it was software professionalism that won the fight, hands-down. Martin was definitely the greatest show on earth. He was animated, he was enthused and he inspired all of us to do better in our testing. Why do not we as developer, designers and architect treat ourselves like blue-collar workers, clocking in by the hour. We are just as professionalism as accounts, bankers , lawyers and other executvies. Great stuff!

Sven (centre) of the NetBeans Dream Team and also Java Duke Award winner 2009 talking to Aaron Houston (out of the picture).

I bought only one book at the conference, a little something on Grails and a companion tome to Scott Davis's Groovy Recipes. By the way, whatever happened to Vaclav Pech's GParalleliser quickie talk. Did I missed it?

Conclusions

What a ride?! Devoxx 2009 was just great. Obviously, I finished this article on the last day of the conference on Friday, 20^th November 2009.

There many items, which I noticed, from previous years, which were missing. The conference ended a couple of hours earlier this year, at lunch time. There was no Friday lunch voucher. There was no daily newspaper and the number of exhibitions were clearly down. Sun Microsystems Belgium were not there this year, for example, which I personally do not care about. However, the let us consider the positives here for a minute. The Java Champions and most of the European JUG leaders / co-JUG leaders were in attendance. You got entrepreneur and really good technical/business people like David Booth coming here, then most of the people in your niché of technology whether it be Groovy, Scala, Fan(tom), SOA, FX or just plain Java around. For me even members of the JAVAWUG , Markus K and Phil Haigh, made it over at the last minute, the conference was not sold out a week before. I think it says something about developers, designers and architects and that they are still hungry of innovation, inspiration and good old community socialisation. Above all, I strongly recommend the Devoxx conference to any Java beginner in Europe who wants to expand their mind, to get ahead and to stay ahead of the pack. Just like "Public Enemy Number One! One, one, one. One, two, three, huue haarggh"

Finally, Parleys.com are offering, now, a subscription to Devoxx Online. For pnly 49.00EU for six months, you can get streamed videos of the conference show as they are transcoded, uploaded and produced on demand. This is great for those of you who could not attend Devoxx and also feel that you need some further education.

This is Peter Pilgrim at Devoxx 2009. Out!

The Shout Outs!

In no special order:

Dave Booth, CEO of Zero Turnaround,
Stephen Janssen, "Mr. Devoxx", himself
Jo Voreendecker, JavaFX and Flex, Devoxx Committee member
Dan Hardiker, Adaptavist, Devoxx Committee member
Stephen Colebourne, Fan(tom) Language Adovocate, Author of First Class Methods Closure Proposal 2008
Aaron Houston, Program Manager, Outreach, Sun Microsystems,
Mike Van Riper, Silicon Valley Web User Group, JUG Leader
Kevin Nilson, Silicon Valley Web User Group, JUG Leader
Valerié Hillaweare, Devoxx Committee member and Congratulations. ( All the best for February 2010 ;-)
Stephen Chin, JFXtras Project
Markus Kobler, JAVAWUG Member, London
Oliver Gierke, JPR09 Housemate
Alex Buckley, JDK 7 Jigsaw, Sun
Brian Goetz, Universal VM and JavaFX Compiler and Runtime
Richard Bair, JavaFX Team, Sun
Jasper Potts, JavaFX Team, Sun
Holly Cummins, IBM Performance (Come on down and present to the LondonJAVAWUG anytime)
Kirk Pepperdine, Kodework (You too),t
Alain Moran, Adaptavist
Keith Brophy, Adaptavist
Frederick Simon, JFrog
Shlomi Ben Haim, Co Founder CEO JFrog
Daniel Wroblewski, Flygpoolen
Marcelo Milano, JUG Milano,
Joe Darcy, Project Jigsaw, Sun Microsystems,
Reggie Hutcherson, Program Director, Outreach, Sun Microsystems
Frenk Greco, New York Java Users Group, KaaZing,
Romain Guy, Curious Creature, Android SDK Google
Dick Wall, Java Posse,
Joe Nuxoll, Java Posse,
Tor Norbye, Java Posse,
Karl Quinn, Java Posse
Antonio Gonclaves, Java EE 6 Export Group member, Paris JUG Leader
Peter Lubbers, CEO, KaaZing
Jevgeni Kabanov, Founder, Chief Technical Officer, ZeroTurnaround
Bill Venners, Scala Test presenter at Devoxx, Artima
Jason van Zyl, Maven 3, Sonatype

JDK7 notes from Devoxx09

Serkan Guler — Fri, 20 Nov 2009 06:20:20 -0500

http://serkanguler.info/2009/11/20/jdk7-notes-from-devoxx09/

Fedora 12

Mario Torre — Fri, 20 Nov 2009 05:22:12 -0500

It‘s out and it‘s nice. And looks like even Microsoft is contributing to it too.

I guess I‘m going to wait a little before “upgrading” this time…

Why JSR-310 isn't Joda-Time

Stephen Colebourne — Fri, 20 Nov 2009 03:44:38 -0500

One question that has been repeatedly asked is why JSR-310 wasn't simply the same as Joda-Time. I hope to expain some reasons here.

Joda-Time as JSR-310?

At its heart, JSR-310 is an effort to add a quality date and time library to the JDK. So, since most people consider Joda-Time to be a quality library, why not include it directly in the JDK?

Well, there is one key reason - Joda-Time has design flaws.

Now before everyone panics and abuses that line as a tweet, I need to say that Joda-Time is by far the best option curently available, and that most users won't appreciate the design flaws. But, I do want to document them, so the basis for the changes in JSR-310 is clear.

1) Human/Machine timelines

One element of clarity is a better understanding of the distinction between the two principle views of the timeline - Human and Machine.

Machines have one view - a single, ever increasing number. In Java we set zero as 1970-01-01T00:00Z and count in milliseconds from there.

Humans have a totally different view of time. We have multiple calendar systems (one primary, many others), which divide the timeline into years, months, days, hours, minutes and seconds. In addition, humans have time zones which cause the values to vary around the globe, and for there to be gaps and overlaps in the human timeline as DST starts and ends.

Much of the time, a conversion between the two timeline views is possible with a time zone, however in a DST gap or overlap, things are much less clear.

Joda-Time defines two key interfaces - ReadableInstant and ReadablePartial. Both the Instant class (simple instant in time) and the DateTime class (human view of an instant in time) are implementations of ReadableInstant. This is wrong.

DateTime is a human-timeline view of the world, not a machine-timeline view. As such, DateTime is much better thought of, and designed as, a LocalDateTime and a timezone rather than the projection of the machine timeline onto the human timeline. Thus, DateTime should not implement ReadableInstant.

2) Pluggable chronology

What is the range of values returned by this method in Joda-Time?:
int month = dateTime.getMonthOfDay();
The answer is not 1 to 12, but could be 1 to 13! (yet January is still 1 and December is 12)

The answer to this puzzler is down to pluggable chronologies. Each date/time class in Joda-Time has a pluggable chronology. This defines the calendar system that is in use. But most users of the API never check to see if the chronology is the standard ISO/ chronology before calling getMonthOfDay(). Yet, the Coptic chronology has 13 months in a year, and thus can return a range of 1 to 13.

A better solution would be to keep the date/time classes restricted to a single calendar system. That way, the result from each method call is clear, and not dependent on any other state in the class, like the chronology.

3) Nulls

Joda-Time accepts null as a valid value in most of its methods. For date/times it means 1970-01-01T00:00Z. For durations it means zero. For peiods it means zero.

This approach causes random bugs if your code happens to provide a null to Joda-Time that you hadn't originally planned for. Instead of throwing an error, Joda-Time continues, and the resulting date/time is going to be different from what you want.

4) Internal implementation

Certain aspects of the internal implementation are complex, and the result of having pluggable chronologies and a misunderstanding of the machine/human divide in the timeline. Changing this is a big change to the code.

One particular area of trouble is managing DST overlaps. The behaviour in Joda-Time of these isn't that well defined.

Summary

Joda-Time isn't broken!

It does the job it was designed for, and does it much better than the JDK. And it is widely used and without too many major issues. However, after a few years, it is now clear where it could be designed better.

I took the decision that I didn't want to add an API to the JDK that had known design flaws. And the changes required weren't just minor. As a result, JSR-310 started from scratch, but with an API 'inspired by Joda-Time'.

I hope that explains the thought process behind the creation of a new API in JSR-310.

Systems Thinking and Maxis

Rickard Öberg — Fri, 20 Nov 2009 01:09:09 -0500

In our StreamFlow project, where we build a workflow system for humans based on GTD, Human Interaction Theory and Systems Thinking, it has been interesting to do research on these topics, and in particular ST. ST states, according to John Seddon, that a worker in a system have roughly 5% impact and the system itself has 95% impact. These are bold numbers, and I've been wondering how accurate they are.

Then today I got an interesting example of this. I'm using the new iPhone 3GS in Malaysia, and the default telco for it is Maxis. Since I mostly wanted to use the data services I signed up for a Value-package which includes 3GB each month, and then I pay extra for calls to other operators. Since my wife is on Celcom there's a non-zero cost to that every month. So far so good.

Then yesterday my phone stopped working! Calling the Maxis hotline number stated that we had not paid our bill! But, we had only received one bill, which we HAD paid. What was going on!?

When we called the Maxis callcenter, using another phone since my own Maxis-connected phone was unusable, we got the explanation. The Value-package I have cost 99RM per month, but the credit limit is 100RM. As I had made a phonecall using the iPhone, the total for the next bill was over 99RM, and so Maxis instantly shut down the phone. So where was the bill? As far as we knew we had paid it! Apparently the new bill was sent a couple of days ago, but had not yet arrived in our mailbox, so there was no way that I could have paid it! In essence, there is no way that I can use the iPhone to make calls without having it be closed down each month between the time they send out the bill and me paying it a couple of days later. The stupidity of this system completely boggles my mind, but there ya go.

The people at the Maxis callcenter did everything correct, answering our questions about how this situation could come about. And there was nothing they could do about it. They were an example of that the system really does represent 95% of what the customer experience is. No matter how nice they were, and they were, my experience of Maxis, as a customer, is absolutely horrible.

Then, a couple of hours later I get an SMS from Maxis:
"Please rate our Maxis staff from 1 to 5. 1=lowest & 5=highest for the customer experience you received recently. Kindly reply to 20002 at no cost to you. TQ"

I understand what they want, they want me to rate the staff taking the call, but as ST shows, and which this example confirms, the staff that took my call has almost nothing to do with my customer experience. Their stupid system is entirely responsible for my lousy customer experience. I responded "1", of course, knowing that this will tell them nothing. They are asking the wrong question, as they have the wrong assumption (that the callcenter staff can influence my customer experience in any significant way). What that "1" really means is that whoever came up with the policy that caused this situation should be instantly fired (first, for causing waste and failure demand in the Maxis system, and second, for giving me a reason to switch operator). Even worse, the higher-up execs at Maxis are also in trouble, as they are not ensuring that there is a system in place whereby Maxis can get relevant feedback (feedback on the system) from customers which would give them actual data to use to improve their business. In the end, this can only cause Maxis to lose revenue and business.

The more I delve into understanding Systems Thinking, and seeing the lack of it in businesses that I deal with on a daily basis, the more I understand just how much potential there is for improvement out there. I hope that we can build some of this understanding into our own products, and can avoid these kinds of problems ourselves. Having a solid method for improving our business and understanding of our customers' needs is essential, and it seems Systems Thinking can help us do that.

UPDATE 2009-11-23: I was called up by Maxis customer support to discuss my concerns. The lady I talked to was most graceful, and did everything correct from the point of view of what she had instructed, even though it was clear that the instructions were, as they say, bollocks. The first attempt at fixing the above issue was to increase the credit limit, which would give me more "space" to make phonecalls without having the phone shutdown. While this would work there are two problems with it: one, I would probably have to pay for a "top up", and second, sometimes I make overseas calls which are quite expensive, and so it could happen that even an increased credit limit that would solve my local calls problems wouldn't be enough.

Seeing this is a generally bad solution I asked for the reason behind this credit limit in the first place. The reasoning was that they wanted to "protect" customers from getting too high bills that they couldn't pay, and so they turn off the phone after the credit limit has been reached. She did say that they send out warning SMS's first, but when I looked I couldn't find any. And even if they did, there's a big chance I would delete it without looking at it, as Maxis sends quite a lot of spam SMS's that I delete without even opening. Another bad business practice that gets in the way of achieving real value for me as a customer, and in the end, for Maxis. All in all, my guess is that they do this just to get people to "top up" the credit limit, which in effect is free money for them even though it is just an inconvenience for the customer.

The second suggestion was that I should call the customer support callcenter if I received a warning SMS, to tell them not to close down my phone and that I would pay it shortly. Since this would happen every month if I don't increase my credit limit I would have to repeat this dance every month. This would obviously create failure demand in the support callcenter (=phone calls that don't bring value to Maxis or me as a customer), and is just pure waste. Still, this is what was suggested. Seriously! Again, I want to emphasize that I don't blame the person calling me, who had no way to help me other than tell me all these stupid suggestions that she had in her scripts, all of which were bad both for Maxis and myself.

The last suggestion was that I should change to have my bills sent by email. Then I would get them quicker and could pay them before they shut off my phone. At this point my mind is boggled quite a bit. She was asking me to change my behaviour (get bill by email instead of snailmail) to compensate for their bad processes. I refused, and said that even if I "fixed" my problem this way, it wouldn't help Maxis or the other customers who did not have this option. It was just a way to "cover up" the bad process, not fix it at its root.

In the end I agreed to let her check if my credit limit could be upped somewhat, with the condition that I should not have to pay extra just to be able to use the phone as a normal user. She would check it out. So that's the status for now.

This again shows that the worker, in this case the lovely callcenter support agent, could not impact my customer experience in the least, as the main problem has to do with the system at Maxis. No performance targets, KPI's, ISO 9000 certifications, or any similar bullshit, would ever be able to fix this. Only a change to the system would.

Update 2009-11-24: The Maxis bill arrived today, and it is even worse than I thought. Initially I thought the issue was that I had made some phone calls with my phone, and that was what crossed me over the credit limit. From the bill, however, it is clear that it would have been shut off even if I hadn't used it at all. Why is that? Because I have the base "Value 50" package (i.e. 50RM monthly), and then I added a monthly data service for 99RM, which together brings the bill to 149RM per month - 49RM above my credit limit. Which causes the phone to be shut off without notice. Why this wasn't pointed out by the Maxis sales when I got the phone is one question to consider, but the main solutions to this problem seems to be: either I have to give Maxis more money up front to increase my credit limit (and I would have had to figure that out on my own, since the sales didn't mention it), or I have to call Maxis every month to say "please don't shut off my phone, I'll pay the bill", and yes, this I would also have to figure out on my own. It's like Maxis don't want customers, or at least not in a way that is beneficial for the customers. It will be really interesting to see just how much stupidity will be exposed once I get to the bottom of this pit of bad business practices.

JAVAWUG BOF 52 What is Oracle Doing With Java?

Peter Pilgrim — Thu, 19 Nov 2009 20:51:10 -0500

JAVAWUG BOF 52 What is Oracle Doing With Java?

Birds-of-a-Feather 52
Thursday,
3^rd December 2009
Oracle City of London Office,
London, UK

Dear All

I would like to formally announce that JAVAWUG (Java Web User Group) is holding the Fifty Second Birds-of-Feather (Meet-up 52) at Oracle City of London Office on Thursday, 3^rd December 2009 from 18:30 until 20:30 .

What is

Doing with Java™?

Headline Talk

Title: Oracle and Java

Speaker: Duncan Mills, Sr. Director, Oracle Development Tools

Whilst the future of the Oracle/ Sun deal is in the hands of the European Union we can't talk in detail about Oracle's plans for Java or any other Sun product. However, in this talk I'll explain exactly how Oracle, as a major consumer of Java in it's own right, uses the Java platform for it's own application development. This will concentrate on the key technologies and frameworks that we use, and why we use them, for building both web user interfaces and other parts of the solution stack.

Biography
Duncan Mills is Senior Director of Product Management for Oracle's development tools and frameworks including both the Oracle JDeveloper IDE, the Oracle Application Development Framework and the Oracle Enterprise Pack for Eclipse. Duncan has been working in the IT industry for 20 years or so both in the UK and the USA. He was one of the earlier members of JavaWUG before callously abandoning the group for the sunny land of California.

Duncan Mill's Blog http://groundside.com/blog/

Google Video: Introduction to JavaServer Faces
Google Video: Quick Introduction to ADF JSF

Support Talk

Title: 15 Java libraries every Java developer should know about
Speaker: Joe Walnes

A quick tour of some high quality libraries that can improve productivity and functionality. Some new, some old. Some well known, some unsung heroes.

I'll give an overview and some examples of things you can do with them. Even if you can't use them immediately, it's always useful to know about the possibilities out there. All of the libraries are open source, and easy to embed in any existing JVM based system.

This will include libraries for: data processing, common utilities, concurrency, performance, scalability, testing, and web apps.

Biography

Joe Walnes leads the software team for DRW London, a proprietary trading organization. In a previous life, Joe has also worked for Google and ThoughtWorks. He founded some Java open source projects, including XStream, SiteMesh, Hamcrest, QDox and Objenesis. But he won't be talking about those. He also co-founded the WebWork, jMock, ActiveMQ, XDoclet and Groovy. Joe's main interests are performance, scalability, concurrency, rich web applications, usability and lean development.

http://joewalnes.com/

http://drw.com/

Registration

Afterwards members can retire to the nearby All Bar One pub/restaurant for more in depth discussion dinner, food and drink ...

The address is:

Oracle City of London
Oracle Corporation UK Ltd.,
One South Place,
London.

EC2M 2RB
Tel: 0207 816 7500
Fax: 0207 816 7555

If you would like to attend:

Please REGISTER so that you can be added to the SECURITY DETAIL with Oracle (EventBrite).
If you aren't a JAVAWUG member why not join the JAVAWUG at Google Groups?

For problems, send an email to peter (dot) pilgrim (at) gmail (dot) com.

Here is some relevant travel information:

By Underground: -
Moorgate: 200 yards from Moorgate Station pass the HMV and Hotel Chocolat. Liverpool Street: 400 yards walk north pass Broadgate exit along Eldon Street
Map: Google Maps Link to 1 South Place

The venue has graciously been organised by Oracle UK team. We all appreciate this generous gift.

JAVAWUG.com

JAVAWUG BOF Videos by Peter Pilgrim is licensed under a Creative Commons Attribution-Non-Commercial-Share Alike 2.0 UK: England & Wales License.

Based on a work at http://jroller.com/javawug.

Media Copyright Notice

JAVAWUG BOF Events are video recorded, edited and published freely. We normally record the speaker and administrators. You can find examples on Vimeo and Google Video. On the rare occasion we do record some audience members. Please let us know if you personally would rather not been filmed. We reserved Some of the Copyright 2009/2010 ©© JAVAWUG Video Productions, Creative Commons License (Attributions: Attribution (by): Licensees may copy, distribute, display and perform the work and make derivative works based on it only if they give the author or licensor the credits in the manner specified by these conditions.).

This is Peter Pilgrim, Out.

Graphing, Django, pyjamas... random thoughts

Rick Hightower — Thu, 19 Nov 2009 14:47:05 -0500

Created the graph daemon 0.1, to pre-generates all the graphs before viewing, I did not use a graph lib, just PIL. I read the data with DOM. I read the data with lxml (python lib DOM with XPath). The graph data comes in huge XML files. I need to rewrite to use SAX for speed. But not right now. I will stick with the lxml version until I get some more time (it is a background daemon, speed it as important this phase... if I get time I will rewrite quickly).

The marketing guys loved the new graphs! I created a high-res version (to zoom into detail) and a low-res version (for speed load time). I will also have to create windows of the graphs for reporting.

Got to work and we had another scheduling system. Django is out of scope for this release. We are going to stick with Spring MVC. We have a quick release cycle and there is no time to retrain the team. I don't have a problem with this. This takes a lot of pressure off of me.

There are some back-end (low visibility) admin mgmt apps that need written. We will use these to introduce Django into the mix for these in Jan. Then once we get a few of these under our belt we will start to use Django for some higher priority stuff.

For RIA pieces, I am still considering GWT or Pyjamas. If I use Pjs, I can resuse some of the graph logic that I have already written (maybe even share modules). If Pjs works out well, the new "desktop" app could go the Pjs route. Then there was one code base to rule them all. One day, there wont be web apps and desktop apps... just apps. That is the Pjs vision... not sure it is a reality.

ReentrantLock Bug?

David Shay — Thu, 19 Nov 2009 08:05:41 -0500

This is the kind of bug that never happens, except when it does. I've been sent the following stack trace:

java.lang.IllegalMonitorStateException
	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:127)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1175)
	at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:431)
        ...

This exception can occur in an unlock() method only if the thread that performs the unlock is not the one that performed the lock. Which was not really the case for me. Here is more or less what my code is doing:

   private Lock theLock = new ReentrantLock();
   private Condition theCondition = theLock.newCondition();
   
   private void await()
   {
      theLock.lock();
      try
      {
         ...
         boolean bHasTimedOut = !theCondition.await( 1, TimeUnit.SECONDS );
         ...
      }
      catch (InterruptedException e)
      {
         e.printStackTrace();
      }
      finally
      {
         theLock.unlock();
      }
   }
   
   private void wake()
   {
      theLock.lock();
      try
      {
         ...
         theCondition.signal();
         ...
      }
      finally
      {
         theLock.unlock();
      }
   }

One thread is waiting for a condition with a timeout, while another will wake it up at some point. They are both working on the same lock, the lock is never modified, neither is it accessed by any other method. And clearly, the thread that holds the lock is the one that will unlock it.

This code ran for million times already without any glitch. Until today. Can it be a JVM bug? (by the way, we run Java 6 build 16).

IBM WebSphere eXtreme Scale 6

Ricardo Sueiras — Thu, 19 Nov 2009 06:51:06 -0500

Those nice people at Packt (thanks Ryan) have sent me a copy of Anthony Chaves‘ book called IBM WebSphere eXtreme Scale 6. I‘ll be reading this over the next couple of weeks and report back my thoughts.

There is a free chapter available on the publishers website here(and actually, looks like they got a WebSphere 7 book I might have to purchse….)

Selecting Web Technologies from Devoxx09

Serkan Guler — Thu, 19 Nov 2009 06:38:02 -0500

http://serkanguler.info/2009/11/19/selecting-web-technologies-from-devoxx09/

Closures in JDK 7

Stephen Colebourne — Thu, 19 Nov 2009 02:53:16 -0500

So, on Wednesday, Mark Reinhold from Sun announced that it was time for closures in Java. This came as a surprise to everyone, but what was announced?

Closures in JDK 7

Mark took the audience through the new features of JDK 7 in his presentation at Devoxx. As part of this he showed the Fork Join framework.

Part of this framework features a set of interfaces to support functional style predicates and transforms. But, in order to implement this in Java required 80 interfaces, all generified, and that only covered 4 of the primitive types! Basically, Mark, and others, had clearly come to the conclusion that this code was important to Java, but that the implementation with single-method interfaces, generics and inner classes was too horrible to stomach for the JDK.

Thus, 'its time to add closures to Java'.

Mark announced that Sun would investigate, and intended to commit, closures to OpenJDK for JDK 7. While there will be no JSR yet, it isn't unreasonable to expect that there will be an open aspect to discussions.

Mark noted that the work in the closures discussion, and particularly the detail in the BGGA proposal, had allowed the options to be properly explored. He emphasised how this had resulted in the decision to reject key aspects of BGGA.

JDK 7 closures will not have control-invocation statements as a goal, nor will it have non-local returns. He also indicated that access to non-final variables was unlikely. Beyond this, there wasn't much detail on semantics, nor do I believe that there has been much consideration of semantics yet.

On syntax, Mark wrote up some strawman syntaxes. These follow the FCM syntax style:

  // function expressions
  #(int i, String s) {
    System.println.out(s);
    return i + s.length();
  }

  // function expressions
  #(int i, String s) (i + s.length())
  
  // function types
  #int(int, String)

Mark also argued that a form of extension methods would be added to allow closures to be used with existing libraries like the collections API.

Although I must emphasise that everything announced was a proposal and NOT based on any specific proposal (BGGA, FCM or CICE). However, the syntax and semantics do follow the FCM proposal quite closely.

In addition, Neal Gafter has produced an initial formal writeup of what was announced derived from BGGA. Based on my initial reading, I believe that Neal's document represents a good place to start from. I also hereby propose that we refer to Neal's document as the CFJ proposal (Closures for Java), as BGGA rather implies control invocation.

So, lets hope the process for closures provides for feedback, and we get the best closures in the style most suitable for Java in JDK 7.

Grails/Griffon stats trick

Andres Almiray — Wed, 18 Nov 2009 18:17:22 -0500

Grails has had a stats script for quite a while (thanks to awesome Glen Smith), it's job is to display how many lines of code you've written on your app. Not to be left behind, Griffon provides the same script. As useful as the script is there is a catch: you can't compute LOCs of additional artifacts that are not defined in the source paths found in the stats script.

Well, you couldn't until recently. Starting with Grails 1.2M4 and Griffon 0.2 you'll be able to plug into the stats script and provide additional paths to be counted. Hows does this work you ask? let me introduce you to build events, as explained at the official Grails guide (Griffon events work exactly the same, cool huh?). The stats plugin will publish a StatsStart event, passing a list of maps as parameter. Each entry on that list defines a path to be searched, files found on that path will be counted if they match a certain criteria, mainly their filetype (actually a file suffix). To give you an example these are the default paths of the Grails stats script
You'll notice that filetype is a list (it used to be a single String). This is useful when joint-compilation is taken into account, a fact that the Griffon stats plugin relies on, as the path src/main main contains both Groovy and Java sources
Alright, so how do you plug into this feature? all you to do is add an event handler in scripts/_Events.groovy, like this one (used by Griffon's Scala plugin)
There is an additional feature, you may redefine how comments and empty lines are matched for a particular path. Provide a value for a locmatcher property. This is how the Griffon Clojure plugin does it:
Finally, the default LOC matcher should give better results when a multiline (/* */) comment is found on the source code.

Keep on Groovying!

Ripped out aggdraw... went back to plain PIL

Rick Hightower — Wed, 18 Nov 2009 16:01:29 -0500

Added the ability to add text annotations to the graphs... I had to rip out aggdraw as there was no decent documentation on how to load a font and no mailing list, and everything I tried failed. I went back to just using PIL. That was a real pisser.

class Canvas:
	pass
 
class ImageCanvas (Canvas):
	"""
	Since the drawing logic will be the same for Pyjamas, PyGTK and images, I want
	to abstract the canvas.
	"""
	def __init__(self, size, file_name="image.png", file_type="PNG"):
		import Image
		import ImageDraw
		import ImageFont
		self.img = Image.new("RGB", size, "#FFFFFF") 
		self.canvas = ImageDraw.Draw(self.img)
		self.width = size[0]
		self.height = size[1]
		self.file_name = file_name
		self.file_type = file_type
                #Nothing says I hate all that is good in the world by adding a absolute path... fix me
                self.font=ImageFont.truetype("/usr/share/fonts/truetype/freefont/FreeSerif.ttf", 15)
 
	def draw_line(self, x, y, x2, y2, color="black", width=1):
		self.canvas.line((x, y, x2, y2), fill=color, width=width)
 
	def draw_string(self, x, y, text, color="black"):
		self.canvas.text((x,y), text, font=self.font, fill=color)
 
	def render(self):
		self.img.save(self.file_name, self.file_type)
 
class SomeGraph:
	"""The drawing logic for this graph is going to grow. 
	It would be good to encapsulate the drawing logic in one place"""
	DURATION_SECONDS = 40
	LARGE_STEP_PER_SECOND = 5
	LARGE_TO_SMALL_FACTOR = 5
 
	def __init__(self, step_size=3, y_offset=0, x_offset=0):
		self.step_size = step_size
		self.large_step_size = self.step_size * self.LARGE_TO_SMALL_FACTOR
		self.height = self.large_step_size * 4
		self.width = self.LARGE_STEP_PER_SECOND * self.DURATION_SECONDS * self.large_step_size
		self.y_offset=y_offset
		self.x_offset=x_offset
 
	def draw_grid_lines(self, canvas):
		#Draw vertical red lines (inner lines)
		for x in range(self.x_offset, self.width+self.x_offset, self.step_size):
			canvas.draw_line(x=x, x2=x, y=self.y_offset, y2=self.height+self.y_offset, color="red")
		#Draw vertical black lines (outer grid)
		for x in range(self.x_offset, self.width+self.x_offset, self.large_step_size): 
			canvas.draw_line(x=x, x2=x, y=self.y_offset, y2=self.height+self.y_offset)
		canvas.draw_line(x=self.width+self.x_offset, x2=self.width + self.x_offset, 
                                 y=self.y_offset, y2=self.height+self.y_offset)
 
		#Draw horizontal lines
		for y in range(self.y_offset, self.height + self.y_offset, self.step_size):
				canvas.draw_line(y=y, y2=y, x=self.x_offset, x2=self.width + self.x_offset, color="red")
				flag=False
		for y in range(self.y_offset, self.height  + self.y_offset, self.large_step_size): 
			canvas.draw_line(y=y, y2=y, x=self.x_offset, x2=self.width  + self.x_offset)
		canvas.draw_line(y=self.height+self.y_offset, y2=self.height+self.y_offset, 
				 x=self.x_offset, x2=self.width  + self.x_offset, width=2)
 
 
 
def draw_graph(step_size=3, file_name="foo.png"):
	SIDE_GUTTER = 50
	TOP_GUTTER = 25
	graph = SomeGraph(step_size=step_size, x_offset=SIDE_GUTTER, y_offset=TOP_GUTTER)
	canvas = ImageCanvas((graph.width+SIDE_GUTTER,graph.height+TOP_GUTTER), file_name=file_name)
	graph.draw_grid_lines(canvas)
	canvas.draw_string(50, 0, "Avg 50,      CVP 20,                 ASDF, alskjdflaksjdflkajsdflkjasdflkjasdfljkasdlkjf")
	canvas.draw_string(5, 5, "Blah")
	canvas.draw_string(5, 20, "Rick")
	canvas.draw_string(5, 35, "Was")
	canvas.draw_string(5, 50, "Here")
	canvas.render()
 
draw_graph()
draw_graph(6,"zoom.png")

California Bans Energy Hogging TVs

Rob Williams — Wed, 18 Nov 2009 15:49:29 -0500

So rare that the california state government does something good! This is a total no brainer. Another exercise in how one person saying ‘my plasma doesn‘t make much difference‘ turns into a catastrophe. Enough savings to power almost a million homes. Insane..

People who argue against this kind of stuff are complete whackjobs. Usually, it just boils down to ‘how dare the nanny state tell ME what to do!!‘ The answer is simple: we all have to pay for the new power plants to run said stupid plasma because the LCD just wasn‘t good enough.

Personally, I favor systems where we actually assess real costs and then we just tax things appropriately. Have to have that huge TV? No problem, you just pay more tax on it.

Read about it here

Abstracting the canvas from the drawing logic (continuation of last blog)

Rick Hightower — Wed, 18 Nov 2009 13:10:16 -0500

Since the drawing logic will be the same for Pyjamas, PyGTK, PDF's and images, I want to abstract the canvas from the graph drawing logic so we can reuse it. Also just a good SOC (separation of concern).

class Canvas:
	pass
 
class ImageCanvas (Canvas):
	"""
	Since the drawing logic will be the same for Pyjamas, PyGTK and images, I want
	to abstract the canvas.
	"""
	def __init__(self, size, file_name="image.png", file_type="PNG"):
		import Image
		import aggdraw as draw
		self.img = Image.new("RGB", size, "#FFFFFF") 
		self.canvas = draw.Draw(self.img)
		self.pens = {"red":draw.Pen("red", 0.25), "black":draw.Pen("black", 0.25) }
		self.width = size[0]
		self.height = size[1]
		self.file_name = file_name
		self.file_type = file_type
 
	def draw_line(self, x, y, x2, y2, color="black"):
		pen = self.pens[color]
		if pen == None: 
			#Todo add logging to this class
			pen = self.pens["black"]
		self.canvas.line((x, y, x2, y2), pen)
 
	def render(self):
		self.canvas.flush().save(self.file_name, self.file_type)
 
 
def drawGraph(step_size=3, file_name="foo.png"):
	STEP_SIZE = step_size
	DURATION_SECONDS = 40
	LARGE_STEP_SIZE = STEP_SIZE * 5
	HEIGHT = STEP_SIZE * 5 * 4
	LS_PER_SECOND = 5 
	WIDTH = LS_PER_SECOND * DURATION_SECONDS * LARGE_STEP_SIZE
	canvas = ImageCanvas((WIDTH, HEIGHT), file_name=file_name)
 
	#Draw vertical red lines (inner lines)
	for x in range(0, WIDTH, STEP_SIZE): canvas.draw_line(x=x, x2=x, y=0, y2=HEIGHT, color="red")
	#Draw vertical black lines (outer grid)
	for x in range(0, WIDTH, LARGE_STEP_SIZE): canvas.draw_line(x=x, x2=x, y=0, y2=HEIGHT)
 
	#Draw horizontal lines
	for y in range(0, HEIGHT, STEP_SIZE): canvas.draw_line(y=y, y2=y, x=0, x2=WIDTH, color="red")
	for y in range(0, HEIGHT, LARGE_STEP_SIZE): canvas.draw_line(y=y, y2=y, x=0, x2=WIDTH)
	canvas.draw_line(y=HEIGHT, y2=HEIGHT, x=0, x2=WIDTH, )
 
	canvas.render()
 
 
drawGraph()
#drawGraph(6,"zoom.png")

Ok this is the last part I can share... I am going to get to specific to the domain in the next steps... cloaking device on...

The drawing logic for the graph is going to grow. It would be good to encapsulate the drawing logic in one place. I separated the drawing logic into a class that uses the canvas.

class Canvas:
	pass
 
class ImageCanvas (Canvas):
	"""
	Since the drawing logic will be the same for Pyjamas, PyGTK and images, I want
	to abstract the canvas.
	"""
	def __init__(self, size, file_name="image.png", file_type="PNG"):
		import Image
		import aggdraw as draw
		self.img = Image.new("RGB", size, "#FFFFFF") 
		self.canvas = draw.Draw(self.img)
		self.pens = {"red":draw.Pen("red", 0.25), "black":draw.Pen("black", 0.25) }
		self.width = size[0]
		self.height = size[1]
		self.file_name = file_name
		self.file_type = file_type
 
	def draw_line(self, x, y, x2, y2, color="black"):
		pen = self.pens[color]
		if pen == None: 
			#Todo add logging to this class
			pen = self.pens["black"]
		self.canvas.line((x, y, x2, y2), pen)
 
	def render(self):
		self.canvas.flush().save(self.file_name, self.file_type)
 
class EcgGraph:
	"""The drawing logic for this graph is going to grow. 
	It would be good to encapsulate the drawing logic in one place"""
	DURATION_SECONDS = 40
	LARGE_STEP_PER_SECOND = 5
	LARGE_TO_SMALL_FACTOR = 5
 
	def __init__(self, step_size=3):
		self.step_size = step_size
		self.large_step_size = self.step_size * self.LARGE_TO_SMALL_FACTOR
		self.height = self.large_step_size * 4
		self.width = self.LARGE_STEP_PER_SECOND * self.DURATION_SECONDS * self.large_step_size
 
	def draw_grid_lines(self, canvas):
		#Draw vertical red lines (inner lines)
		for x in range(0, self.width, self.step_size):
			canvas.draw_line(x=x, x2=x, y=0, y2=self.height, color="red")
		#Draw vertical black lines (outer grid)
		for x in range(0, self.width, self.large_step_size): 
			canvas.draw_line(x=x, x2=x, y=0, y2=self.height)
 
		#Draw horizontal lines
		for y in range(0, self.height, self.step_size): 
			canvas.draw_line(y=y, y2=y, x=0, x2=self.width, color="red")
		for y in range(0, self.height, self.large_step_size): 
			canvas.draw_line(y=y, y2=y, x=0, x2=self.width)
		canvas.draw_line(y=self.height, y2=self.height, x=0, x2=self.width, )
 
 
 
def draw_graph(step_size=3, file_name="foo.png"):
	graph = EcgGraph(step_size=step_size)
	canvas = ImageCanvas((graph.width, graph.height), file_name=file_name)
	graph.draw_grid_lines(canvas)
	canvas.render()
 
 
draw_graph()

The drawing logic for the graph is going to grow. It would be good to encapsulate the drawing logic in one place. I separated the drawing logic into a class that uses the canvas.

class Canvas:
	pass
 
class ImageCanvas (Canvas):
	"""
	Since the drawing logic will be the same for Pyjamas, PyGTK and images, I want
	to abstract the canvas.
	"""
	def __init__(self, size, file_name="image.png", file_type="PNG"):
		import Image
		import aggdraw as draw
		self.img = Image.new("RGB", size, "#FFFFFF") 
		self.canvas = draw.Draw(self.img)
		self.pens = {"red":draw.Pen("red", 0.25), "black":draw.Pen("black", 0.25) }
		self.width = size[0]
		self.height = size[1]
		self.file_name = file_name
		self.file_type = file_type
 
	def draw_line(self, x, y, x2, y2, color="black"):
		pen = self.pens[color]
		if pen == None: 
			#Todo add logging to this class
			pen = self.pens["black"]
		self.canvas.line((x, y, x2, y2), pen)
 
	def render(self):
		self.canvas.flush().save(self.file_name, self.file_type)
 
class SomeGraph:
	"""The drawing logic for this graph is going to grow. 
	It would be good to encapsulate the drawing logic in one place"""
	DURATION_SECONDS = 40
	LARGE_STEP_PER_SECOND = 5
	LARGE_TO_SMALL_FACTOR = 5
 
	def __init__(self, step_size=3):
		self.step_size = step_size
		self.large_step_size = self.step_size * self.LARGE_TO_SMALL_FACTOR
		self.height = self.large_step_size * 4
		self.width = self.LARGE_STEP_PER_SECOND * self.DURATION_SECONDS * self.large_step_size
 
	def draw_grid_lines(self, canvas):
		#Draw vertical red lines (inner lines)
		for x in range(0, self.width, self.step_size):
			canvas.draw_line(x=x, x2=x, y=0, y2=self.height, color="red")
		#Draw vertical black lines (outer grid)
		for x in range(0, self.width, self.large_step_size): 
			canvas.draw_line(x=x, x2=x, y=0, y2=self.height)
 
		#Draw horizontal lines
		for y in range(0, self.height, self.step_size): 
			canvas.draw_line(y=y, y2=y, x=0, x2=self.width, color="red")
		for y in range(0, self.height, self.large_step_size): 
			canvas.draw_line(y=y, y2=y, x=0, x2=self.width)
		canvas.draw_line(y=self.height, y2=self.height, x=0, x2=self.width, )
 
 
 
def draw_graph(step_size=3, file_name="foo.png"):
	graph = SomeGraph(step_size=step_size)
	canvas = ImageCanvas((graph.width, graph.height), file_name=file_name)
	graph.draw_grid_lines(canvas)
	canvas.render()
 
 
draw_graph()
draw_graph(6,"zoom.png")

Grails was so electric, it brought down the power grid

Pratik Patel — Wed, 18 Nov 2009 12:50:08 -0500

Last nite's AJUG started off great. Burr, our venerable AJUG leader, started with a discussion on what stuff people wanted to see covered in AJUG in 2010. Next on deck was my Grails presentation. I purposely had the first half of it at a basic level, for the Grails newb's in the crowd. Based on the feedback and attention level, I was rockin' and rollin' - people were asking questions, nodding heads during the basic Grails create-a-project-create-a-domain-gen-a-controller-and-views-demo. Demo'd the RichUI plugin and also some of the features of STS and the Eclipse-Grails plugin. Was on the home stretch, 30 mins left, and was about to demo G-Func and some other cool plugins and start to dive real deep into Grails goodness, when POOF. Lights went on and off.

No problem, gave the projector a couple of mins to restart and starting yapping again. Then POOF, power flickered on-and-off. The torrential rain that had been hammering Atlanta had subsided a week earlier, so we were all wondering what was going on. I figured that the Amway rally that was going on next door was sucking all our electricity. So again I wait for the projector to restart, and again, BANG, power is gone. And it doesn't come back on this time. Burr runs to the hotel manager, comes back and says the power was out on the whole city block.

Funny thing is that people were so engaged in the Grails world by this time that I continued to answer questions for the next 15 mins in the near total dark - a surreal experience. Room full of 80+ people, only light is my laptop's screen. Finally, people sensed that the power wasn't coming back so the meeting came to an unceremonious end. I threw out the t-shirts I had "acquired" from SpringOne. We didn't have time (or lighting) to raffle off the Grails books that Keegan Kettering, our local SpringSource sales guy, had sent for the meeting. We'll do that at the beginning of next month's meeting. I'm hoping I get to finish off the last 20 or so mins of my Grails presentation also.

Our Devoxx 2009 Talk on Google Appengine Was a Blast

Sam Brodkin — Wed, 18 Nov 2009 12:08:07 -0500

Scott and I did a talk on Google App Engine for Java at Devoxx 2009. For the results of our experiment, check out our SwagSwap results and analysis site.

We talked about Appengine Gotchas when developing a non-trivial app. We gave Spring 3 MVC, JSF 2.0, and GWT a spin. The climax was undoubtedly when we gave away big beers to the attendees that used our SwagSwap app the most.

Check out what people are saying. Also look how much swag I got out of the deal!

TuneUp: What is So Hard About Cleaning Up ID3s?

Rob Williams — Wed, 18 Nov 2009 10:45:23 -0500

After reading a bunch of reviews, I decided to buy TuneUp. Even though laptops now have 8GBs of RAM, I have started to hawk apps that piddle away resources because it makes no sense to take all the latest technology that companies have to offer in batteries and just flush it down the toilet. That‘s what TuneUp does. It looks like the work of someone whose ADHD is being combatted with criminal amounts of ritalin; clearly, no one at this company got the memo that frantic, breathless huffing and puffing from any app is a bad idea, but from a sidecar is downright ludicrous. Um, I was just hoping to get all my Mahler under one folder that says simply Gustav Mahler… ??

Here‘s TuneUp topping the CPU suckers list:

One more little treasure: it writes itself into every bloody track (credit is best when you can just go get it yourself!):

In the commission of these duties, I also was fiddling with rsync and ChronoSync because I finally moved all my tunes to NAS. But now, I have figured out how to bring the tunes in from the NAS and I‘m just editing them with iTunes.

I forgot to mention I installed it on my laptop and desktop and now it says I have to call support. Apple lets me play tunes I buy on 5 devices, TuneUp goes into lockdown on #2.

Revisiting PyUnit Once Again

evans — Tue, 17 Nov 2009 22:08:21 -0500

I love working with Python, I learned TDD with PyUnit, but since moved to using Ruby, and have been spoilt by rspec and even cucumber. My instincts are to write things test first, but so far I'm not finding PyUnit easy enough to get going again for some weird reason.

Once I get into the groove, I find it's a wonderful way to work - and avoids some of the drivel I've come up with in the last few days.

As a discipline - I always ask my team members to work out what we want to test, write the test, watch it fail, make it pass - I find this a very productive way to think and work. This simplicity and the elegance that PyUnit provides are some of the reasons why I keep coming back to Python.

Griffon: Scala & Clojure updates

Andres Almiray — Tue, 17 Nov 2009 20:10:50 -0500

New versions of the Scala and Clojure Griffon plugins have been released. These are the highlights:

Scala

Updated bundled libs to Scala 2.7.7 final.
Added scala-repl script. You'll now be able to launch an application interactively and prod at it using a Scala REPL.
Added Scalatest 1.0 support via scala-test script. There are plenty of configurable options for you to tweak and tune.
Added Scalacheck 1.6 support via scala-check script.

Both scala-test and scala-check produce reports that are not yet integrated with the standard reporting mechanism. This feature may be implemented in a future release.

Clojure

Synchronized the plugin with its Grails counterpart, as it had been updated with a few bug fixes and features, like support for Clojure macros and type conversions.
Added create-clojure-script script. Creates a new Clojure script in $basedir/griffon-app/resources/clj.
Added create-clojure-class script. Creates a new Clojure (macro based) class in $basedir/src/clojure.
Added clojure-repl script. Similar to its Scala counterpart, you'll be able to launch an application in interactive mode inside a Clojure REPL.

Keep on Groovying!

Notes on creating GIF, PNG images in Python (first note) with PIL and aggdraw

Rick Hightower — Tue, 17 Nov 2009 17:46:08 -0500

Seems PIL is the way to go to create GIF, PNG and JPGs dynamiclly in python. You get a 2D API. PIL comes with a 2D API, but the PIL site seems to recommend using aggdraw on top of PIL.

This site has an example of using PIL's 2D API:

http://lost-theory.org/python/dynamicimg.html

Here is an example (I created) of using both PIL and aggdraw:

import Image
 
img = Image.new("RGB", (1000,2000), "#FFFFFF")
 
import aggdraw as draw
 
canvas = draw.Draw(img)
 
pen = draw.Pen("black", 0.5)
 
canvas.line((5,20,200,100), pen)
 
canvas.line((0,500,500,0), draw.Pen("blue", 0.7))
 
canvas.flush()
 
img.save("love.png", "PNG")
 
img.save("love.gif", "GIF")

PIL seems to come with my flavor of Ubuntu (9.0.4 rouwdy rick...), but aggdraw does not so you have to get it as follows:

$ svn co http://svn.effbot.org/public/tags/aggdraw-1.2a3-20060212 aggdraw
$ cd aggdraw
$ sudo python setup.py install

There is an executable for Windows but no installer for xNix.

Here is a more involved example that draws grid paper in very long strips.

import Image
import aggdraw as draw
 
def drawGraph(step_size=3, file_name="foo.png"):
	STEP_SIZE = step_size
	DURATION_SECONDS = 40
	LARGE_STEP_SIZE = STEP_SIZE * 5
	HEIGHT = STEP_SIZE * 5 * 4
	LS_PER_SECOND = 5 
	WIDTH = LS_PER_SECOND * DURATION_SECONDS * LARGE_STEP_SIZE
 
	img = Image.new("RGB", (WIDTH, HEIGHT), "#FFFFFF") 
	canvas = draw.Draw(img)
	black_pen = draw.Pen("black", 0.25)
	blue_pen = draw.Pen("red", 0.25)
 
	for x in range(0, WIDTH, STEP_SIZE): canvas.line((x,0,x,HEIGHT), blue_pen)
	for x in range(0, WIDTH, LARGE_STEP_SIZE): canvas.line((x,0,x,HEIGHT), black_pen)
	for y in range(0, HEIGHT, STEP_SIZE): canvas.line((0,y,WIDTH,y), blue_pen)
	for y in range(0, HEIGHT, LARGE_STEP_SIZE): canvas.line((0,y,WIDTH,y), black_pen)
	canvas.line((0,HEIGHT,WIDTH,HEIGHT), black_pen)
 
	canvas.flush().save(file_name, "PNG")
 
drawGraph()
drawGraph(6,"zoom.png")

ICEfaces Tag Reference

Ted Goddard — Tue, 17 Nov 2009 12:29:20 -0500

Here's a great ICEfaces tag reference. Even if you have the TLD handy, you will find the JSFToolbox reference useful because it is very concise and contains screenshots. And while you're there, be sure to check out the design-time extensions for Dreamweaver.

Are you designing dynamic web applications using Dreamweaver? JSF is an ideal technology for this, but it's something the ICEfaces community lacks experience with, because the community is almost entirely composed of Java developers. Making Ajax Push applications easy to design is very important, so please let us know what is needed to make ICEfaces easy to use outside of a traditional Java IDE shop.

Spring 3.0 REST example

Solomon Duskis — Tue, 17 Nov 2009 11:27:02 -0500

I've been working on getting a REST + Hibernate application using the goodies found in Spring 3.0 for my upcoming book - Spring Persistence with Hibernate. I'm unfortunately slightly disappointed at the current state of affairs (sorry Arjen and Chris). Spring 3.0 is in RC2, meaning it's had 2 Release Candidates, but the REST stuff is still not 100% right. I was able to work around issues, but I shouldn't have had to deal with the issues I dealt with had Spring REST been a battle tested in production. I'm going to levarage my work show you how to get a basic application up and running so that you can see exactly what I mean. My application is going to use maven, Spring 3.0, Spring MVC (REST), Spring OXM, Jetty, Hibernate and an in-memory database using H2. You can download a ZIP file: gallery.zip.

Maven is the logical first place to start. If you don't have maven installed, then do it. Choose a top level folder for your project (mine is c:\dev\springpersitence\gallery) and run mvn archetype:create -DgroupId=com.smartpants.artwork -DartifactId=gallery to create the project. (You can switch your groupId to match com.yourcompany.project). Update the pom.xml to import a whole bunch of dependencies from a whole bunch of repositories: We're also going to set up an embedded Jetty instance:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
      http://maven.apache.org/POM/4.0.0
      http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.smartpants.artwork</groupId>
  <artifactId>gallery</artifactId>
  <packaging>war</packaging>
  <name>Artwork Gallery App</name>
  <version>0.1</version>
  <description />

  <build>
    <finalName>gallery-web-app</finalName>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.6</source>
          <target>1.6</target>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.mortbay.jetty</groupId>
        <artifactId>maven-jetty-plugin</artifactId>
        <version>6.1.15</version>
        <configuration>
          <!--
            By default the artifactId is taken, override it with
            something simple
          -->
          <contextPath>/</contextPath>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <properties>
    <spring.framework.version>3.0.0.RC2</spring.framework.version>
    <org.slf4j.version>1.5.2</org.slf4j.version>
  </properties>

  <dependencies>
    <!-- Spring  -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.framework.version}</version>
      <exclusions>
        <exclusion>
          <groupId>quartz</groupId>
          <artifactId>quartz</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${spring.framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>${spring.framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.framework.version}</version>
    </dependency>
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib-nodep</artifactId>
      <version>2.1_3</version>
    </dependency>
    <dependency>
      <groupId>javax.xml.bind</groupId>
      <artifactId>jaxb-api</artifactId>
      <version>2.0</version>
    </dependency>

    <!-- Hibernate -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-annotations</artifactId>
      <version>3.4.0.GA</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate</artifactId>
      <version>3.2.6.ga</version>
    </dependency>
    <dependency>
      <groupId>javax.persistence</groupId>
      <artifactId>persistence-api</artifactId>
      <version>1.0</version>
    </dependency>
    <dependency>
      <groupId>javassist</groupId>
      <artifactId>javassist</artifactId>
      <version>3.11.0.GA</version>
    </dependency>

    <!-- Database -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.2.1</version>
    </dependency>
    <dependency>
      <groupId>commons-collections</groupId>
      <artifactId>commons-collections</artifactId>
      <version>3.2.1</version>
    </dependency>
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <version>1.2.122</version>
    </dependency>
    <dependency>
      <groupId>javax.transaction</groupId>
      <artifactId>jta</artifactId>
      <version>1.1</version>
    </dependency>

    <!-- JUnit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.5</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${org.slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-simple</artifactId>
      <version>${org.slf4j.version}</version>
    </dependency>

    <dependency>
      <groupId>org.mortbay.jetty</groupId>
      <artifactId>maven-jetty-plugin</artifactId>
      <version>6.1.15</version>
    </dependency>

  </dependencies>

  <repositories>
    <repository>
      <id>ibiblio mirror</id>
      <url>http://mirrors.ibiblio.org/pub/mirrors/maven2/</url>
    </repository>
    <repository>
      <id>Springframework milestone</id>
      <url>http://maven.springframework.org/milestone</url>
    </repository>
    <repository>
      <id>jboss</id>
      <url>http://repository.jboss.org/maven2</url>
    </repository>
    <repository>
      <id>java.net</id>
      <url>https://maven-repository.dev.java.net/nonav/repository</url>
      <layout>legacy</layout>
    </repository>
    <repository>
      <id>codehaus</id>
      <url>http://repository.codehaus.org</url>
    </repository>
    <repository>
      <id>atlassian</id>
      <url>http://repository.atlassian.com/maven2</url>
    </repository>
    <repository>
      <id>maven2-repository.dev.java.net</id>
      <name>Java.net Repository for Maven</name>
      <url>http://download.java.net/maven/2/</url>
      <layout>default</layout>
    </repository>
  </repositories>
  <pluginRepositories>
    <pluginRepository>
      <id>maven2-repository.dev.java.net</id>
      <url>http://download.java.net/maven/2</url>
    </pluginRepository>
    <pluginRepository>
      <id>maven-repository.dev.java.net</id>
      <name>Java.net Maven 1 Repository (legacy)</name>
      <url>http://download.java.net/maven/1</url>
      <layout>legacy</layout>
    </pluginRepository>
  </pluginRepositories>
</project>

Spring XML Configuration

Next, you'll need a couple of Spring configuration files. We'll put those files in src/resources. The first file, spring-context is going to be to set up hibernate (including classpath scanning for @Entity object), create the database (using the new jdbc namespace), setup Spring classpath scanning (for Spring beans annotated with @Controller, @Repository & etc.) and setup transaction management:

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
  xmlns:p="http://www.springframework.org/schema/p"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/jdbc
	http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd">

  <context:component-scan base-package="com.smartpants.artwork" />
  <jdbc:embedded-database id="dataSource" type="H2" />

  <bean id="sessionFactory"
    class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"
    p:dataSource-ref="dataSource" p:lobHandler-ref="defaultLobHandler"
    p:packagesToScan="com.smartpants.artwork.domain">
    <property name="hibernateProperties">
      <value>
        hibernate.dialect=org.hibernate.dialect.H2Dialect
        hibernate.show_sql=true
        hibernate.hbm2ddl.auto=create
      </value>
    </property>
  </bean>

  <bean id="defaultLobHandler" class="org.springframework.jdbc.support.lob.DefaultLobHandler" />
  <bean id="transactionManager"
    class="org.springframework.orm.hibernate3.HibernateTransactionManager"
    p:sessionFactory-ref="sessionFactory" />
  <tx:annotation-driven proxy-target-class="true" />
</beans>

We'll also create another Spring XML file which is more geared towards the REST aspects of our projects. We're going to setup Spring @MVC annotation processing, and XML processing through JAXB.

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  xmlns:aop="http://www.springframework.org/schema/aop" xmlns:p="http://www.springframework.org/schema/p"
  xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
 
  xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
           http://www.springframework.org/schema/jdbc
		   http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd">

  <bean
    class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />
  <bean
    class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
    <property name="messageConverters">
      <list>
        <ref bean="marshallingHttpMessageConverter"/>
      </list>
    </property>
 </bean>

  <bean id="marshallingHttpMessageConverter"
    class="org.springframework.http.converter.xml.MarshallingHttpMessageConverter"
    p:marshaller-ref="jaxb2Marshaller" p:unmarshaller-ref="jaxb2Marshaller" />

  <bean id="jaxb2Marshaller" class="com.smartpants.artwork.controllers.MyJaxb2Marshaller">
    <property name="classesToBeBound">
      <list>
        <value>com.smartpants.artwork.domain.Person</value>
        <value>com.smartpants.artwork.domain.People</value>
      </list>
    </property>
  </bean>

  <context:component-scan base-package="com.smartpants.artwork.controllers" />
  <tx:annotation-driven proxy-target-class="true" />

</beans>

There are two things I don't like about this:

Notice that I had to create com.smartpants.artwork.controllers.MyJaxb2Marshaller. That's to get around a problem that OXM has when working with Hibernate proxied objects, which IMHO is a fundamental test case for a Java REST system). Essentially, Spring OXM/JAXB only checks for the @XMLRootElement only on the class itself, and not on the parent classes (like the JAX-RS implementation other Spring subsystems). The hibernate proxy process subclasses your base object (in my case Person) and doesn't add the @XMLRootElement annotation to the subclass. My workaround:
```
package com.smartpants.artwork.controllers;

import javax.xml.bind.annotation.XmlRootElement;

import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;

public class MyJaxb2Marshaller extends Jaxb2Marshaller {

  @Override
  public boolean supports(Class clazz) {
    return super.supports(clazz) ? true : AnnotationUtils.findAnnotation(clazz,
        XmlRootElement.class) != null;
  }
}
```
The Spring framework comes with some great annotation processing utilities that Spring OXM doesn't use... Like I said earlier, this doesn't seem battle tested to me.
Why the heck do I need to create the "classesToBeBound" list? The JAX-RS frameworks don't need anything like that... My guess is that this is a legacy from OXM being a WS-* based system.

Domain objects

My single domain object is pretty simple. I need a Person table/entity in my system. It represents a logical user of my system. It plays the dual role of Hibernate object and an object for my REST interface.

package com.smartpants.artwork.domain;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Version;
import javax.xml.bind.annotation.XmlRootElement;

@Entity
@XmlRootElement
public class Person implements Serializable {
  private static final long serialVersionUID = 1L;

  private Long id;
  private String firstName;
  private String lastName;
  private String username;
  private String password;
  private int roleLevel;

  private Integer version;

  public Person() {

  }

  public Person(String firstName, String lastName, String username,
      String password, int roleLevel) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.username = username;
    this.password = password;
    this.roleLevel = roleLevel;
  }

  @Id
  @GeneratedValue
  public Long getId() {
    return id;
  }

  public void setId(Long id) {
    this.id = id;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public String getUsername() {
    return username;
  }

  public void setUsername(String username) {
    this.username = username;
  }

  public String getPassword() {
    return password;
  }

  public void setPassword(String password) {
    this.password = password;
  }

  public int getRoleLevel() {
    return roleLevel;
  }

  public void setRoleLevel(int roleLevel) {
    this.roleLevel = roleLevel;
  }

  @Version
  public Integer getVersion() {
    System.out.println("getting version " + getLastName());
    return version == null ? 1 : version;
  }

  public void setVersion(Integer version) {
    this.version = version;
  }

  public enum RoleLevel {
    ADMIN(1), GUEST(2), PUBLIC(3);
    private final int level;

    RoleLevel(int value) {
      this.level = value;
    }

    public static RoleLevel getLevel(String roleName) {
      return RoleLevel.valueOf(roleName);
    }

    public int getLevel() {
      return this.level;
    }
  }

}

Using JAXB generally requires a wrapper object, so I decided to create a People JAXB object:

package com.smartpants.artwork.domain;

import java.io.Serializable;
import java.util.List;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class People implements Serializable {
  private static final long serialVersionUID = 1L;

  private List<Person> person;

  public People() {
    // empty constructor required for JAXB
  }

  public People(List person) {
    this.person = person;
  }

  public List<Person> getPerson() {
    return person;
  }

  public void setPerson(List person) {
    this.person = person;
  }
}

DAOs

The DAOs aren't exactly new technology, but I'll add them for completeness. Like a good boy, I created a PersonDao interface and PersonDaoHibernate implementation. I've gotten accustomed to Grails/GORM's niceties over the last few months, and the interface kind of bothered me... but that's a post for another time. The PersonDao:

package com.smartpants.artwork.dao;

import java.util.List;

import com.smartpants.artwork.domain.Person;
import com.smartpants.artwork.exception.AuthenticationException;

public interface PersonDao {

  public Person getPerson(Long personId);

  public void savePerson(Person person);

  public List<Person> getPeople();

  public Person getPersonByUsername(String username);

  public Person authenticatePerson(String user, String password)
      throws AuthenticationException;
}

The hibernate implementation (notice the super.setupSessionFactory() hack I had to do to get @Autowired to work):

package com.smartpants.artwork.dao.hibernate;

import static java.lang.String.format;

import java.util.List;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import com.smartpants.artwork.dao.PersonDao;
import com.smartpants.artwork.domain.Person;
import com.smartpants.artwork.exception.AuthenticationException;

@Repository
@Transactional
@SuppressWarnings("unchecked")
public class PersonDaoHibernate extends HibernateDaoSupport implements
    PersonDao {

  @Autowired
  public void setupSessionFactory(SessionFactory sessionFactory) {
    this.setSessionFactory(sessionFactory);
  }

  public Person getPerson(Long personId) throws DataAccessException {
    return this.getHibernateTemplate().load(Person.class, personId);
  }

  @Transactional(readOnly = false, propagation = Propagation.REQUIRED)
  public void savePerson(Person person) throws DataAccessException {
    this.getHibernateTemplate().saveOrUpdate(person);
  }

  public List getPeople() throws DataAccessException {
    return this.getHibernateTemplate().find("select people from Person people");
  }

  public Person getPersonByUsername(String username) {
    List people = this.getHibernateTemplate().findByNamedParam(
        "select people from Person people "
            + "where people.username = :username", "username", username);
    Person person = getFirst(people);
    if (person != null)
      getHibernateTemplate().evict(person);
    return person;
  }

  public Person authenticatePerson(String username, String password)
      throws AuthenticationException {
    List validUsers = this.getHibernateTemplate().findByNamedParam(
        "select people from Person people "
            + "where people.username = :username "
            + "and people.password = :password",
        new String[] { "username", "password" },
        new String[] { username, password });

    if (validUsers.isEmpty())
      throw new AuthenticationException(format("Could not authenticate %s",
          username));
    return getFirst(validUsers);
  }

  private static <T> T getFirst(List<T> list) {
    return CollectionUtils.isEmpty(list) ? null : list.get(0);
  }
}

Controller

I wanted to build a really simple PersonController that did a POST for adding a new Person at "/people", with a GET at "/people" returning all Person objects (wrapped in a People object), and a GET at "/people/{id}". It's pretty straight forward, but is a bit more verbose that a JAX-RS equivalent:

package com.smartpants.artwork.controllers;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.view.RedirectView;

import com.smartpants.artwork.dao.PersonDao;
import com.smartpants.artwork.domain.People;
import com.smartpants.artwork.domain.Person;

@Controller
@RequestMapping("/people")
@Transactional()
public class PersonController {

  private PersonDao personDao;

  @Autowired
  public void setPersonDao(PersonDao personDao) {
    this.personDao = personDao;
  }

  @RequestMapping(method = RequestMethod.GET)
  public People getAll() {
    return new People(personDao.getPeople());
  }

  @RequestMapping(value = "/{id}", method = RequestMethod.GET)
  @ResponseBody
  public Person getPerson(@PathVariable("id") Long personId) {
    return personDao.getPerson(personId);
  }

  @RequestMapping(method = RequestMethod.POST)
  @Transactional(readOnly = false)
  public View savePerson(@RequestBody Person person) {
    personDao.savePerson(person);
    return new RedirectView("/people/" + person.getId());
  }
}

web.xml

The web.xml is pretty standard fare for Spring MVC:

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
  version="2.4">

  <display-name>ArtworkWeb</display-name>
  <description>ArtWork</description>
  <distributable />

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-context.xml</param-value>
  </context-param>

  <filter>
    <filter-name>hibernateFilter</filter-name>
    <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
  </filter>

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>

  <servlet>
    <servlet-name>artworkWeb</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-dispatcher.xml</param-value>
    </init-param>
    <load-on-startup>2</load-on-startup>
  </servlet>

  <!--
    - Dispatcher servlet mapping for the web user interface, - refering
    to the "image" servlet above.
  -->
  <servlet-mapping>
    <servlet-name>artworkWeb</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>

  <filter-mapping>
    <filter-name>hibernateFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

</web-app>

Jetty & RESTClient

I use RESTClient to test out HTTP. To run our new application, run mvn jetty:run in a command line in your project (I can't seem to get my Eclipse plugins to execute this for me... but theoretically that should work as well). If you'd like to debug your application, set a system variable MAVEN_OPTS to -Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,address=4000,server=y,suspend=n.

You should get a long log that ends with statements that your /person/ mappings are mapped to PersonController methods. From there you can open up RESTClient, and open up a file with the following contents that set up a POST to /person:

<?xml version="1.0" encoding="UTF-8"?>
<rest-client version="2.3"><request><http-version>1.1</http-version><URL>http://localhost:8080/people</URL><method>POST</method><headers><header key="ACCEPT" value="application/xml"/></headers><body content-type="application/xml" charset="UTF-8">&lt;person&gt;&#x0D;
    &lt;firstName&gt;Solomon&lt;/firstName&gt;&#x0D;
    &lt;lastName&gt;Solomon&lt;/lastName&gt;&#x0D;
    &lt;username&gt;Solomon&lt;/username&gt;&#x0D;
    &lt;password&gt;foo&lt;/password&gt;&#x0D;
&lt;/person&gt;</body></request></rest-client>

Conclusion

I couldn't find much documentation, and had to ask the Spring guys and they were pretty helpful. I think that the Spring Framework's REST development approach is sound, but it doesn't seem to be battle tested yet. Meaning, it seems to be missing features that should exist if this subsystem were broadly deployed. It took me way too long to set up this simple test case, and I had to do a relatively ugly workaround for something that should have been there already. I like Spring's approach, but I'd be hesitant to use it on a big scale app, since you usually end up needing a some feature late in the game... the kind of features that don't exist in less mature platforms

XMLHttpRequest to server side by pure javascript

Serkan Guler — Tue, 17 Nov 2009 10:28:56 -0500

http://serkanguler.info/2009/11/17/xmlhttprequest-to-server-side-by-pure-javascript/

Joda-Money 0.5

Stephen Colebourne — Tue, 17 Nov 2009 06:10:13 -0500

I've just released v0.5 of Joda-Money. It is a simple money and currency package along the lines of Joda-Time.

Joda-Money 0.5

Joda-Money is a project to provide a small, focussed monetary library for Java, similar to Joda-Time. I released v0.5 this morning.

Website, Javadoc, Download, Maven 2 repo

The code is all tested and there are no known bugs. But I wouldn't suggest using it in production code quite yet. I do want lots of feedback and testing though! So, all feedback is welcomed, here, the forum or the list.

The main API is as I originally intended. There is a Money and BigMoney class, the former decorates the latter to restrict the number of decimal places to the currency scale.

There is also CurrencyUnit and a provided data file of currency data. Finally, there is printing (but not parsing yet).

The goal of the library remains just these basic classes. Financial calculations (for whatever domain) or classes storing specific concepts like gross/net/tax are out of scope for the library.

This release is part of the 'release early' approach. Please provide as much feedback as you can!

First experience with Go

Bob Foster — Tue, 17 Nov 2009 05:56:07 -0500

Since jroller doesn't work reliably with Safari, I've moved on. But this post on Google's new Go language may be of interest to some.

Spring Roo JaxItalia Slides

Massimiliano Dessì — Tue, 17 Nov 2009 04:24:35 -0500

Spring Roo JaxItalia09

View more documents from Massimiliano Dessì.

Spring Best Practices JaxItalia Slides

Massimiliano Dessì — Tue, 17 Nov 2009 04:20:59 -0500

Jaxitalia09 Spring Best Practices

View more documents from Massimiliano Dessì.

Spring 3 JaxItalia Slides

Massimiliano Dessì — Tue, 17 Nov 2009 04:15:57 -0500

Spring3.0 JaxItalia09

View more documents from Massimiliano Dessì.

Griffon: visualizing an object graph

Andres Almiray — Mon, 16 Nov 2009 22:23:37 -0500

You might have read before about Griffon's JUNG plugin and wondered "how can I visualize an arbitrary object graph with it?", if so then the following steps should give you a few hints.

Let's start by fleshing out the domain. I realize that at the time of writing this post Griffon does not support domain classes like Grails does (i.e, with GORM & scaffolding enabled), however you can create them in the same fashion, that is, place your domain classes under griffon-app/domain and have them participate on your app. With that in mind let's create a few domain classes related to the book publishing business, mainly a Publisher, a Book and an Author classes, like this:
If you're familiar with ObjectGraphBuilder you know you can populate an object graph with ease, as long as the domain classes follow the JavaBeans conventions. Luckily for us that is the case. Building a graph is as easy as executing the following code:
Nothing fancy, just what you would expect from a Groovy builder, isn't it? by the way I'm using the current list of Groovy related books published by Manning as an example. Alright, now comes the "tricky" part: transforming an object graph into something capable of being visualized with JUNG. I'm glad to say this task is also a simple one. We can instruct ObjectGraphBuilder to populate a JUNG Graph at the same time it builds the domain graph, after all ObjectGraphBuilder is quite extensible. There are two things to be done in order to achieve this goal:

set the root node.
append child nodes to their corresponding parents.

The following Griffon model shows how these two tasks can be done:

import edu.uci.ics.jung.graph.Graph
import edu.uci.ics.jung.graph.DelegateTree

class BooksModel {
   Graph publishers = new DelegateTree()

BooksModel() {
      def ogb = new ObjectGraphBuilder()

def childPropertySetter = ogb.childPropertySetter
      ogb.childPropertySetter = { parent, child, parentName, childName ->
         childPropertySetter.setChild(parent, child, parentName, childName)
         publishers.addChild("'${parent}' - '${child}'", parent, child) // TASK 2
      }

ogb.publisher(name: "Manning") {
         publishers.addVertex(current) // TASK 1
         book(title: "Groovy in Action") {
            author(name: "Dierk König")
            author(name: "Guillaume Laforge")
            author(name: "Paul King")
            author(name: "Andy Glover")
            author(name: "Jon Skeet")
         }
         book(title: "Grails in Action") {
            author(name: "Glen Smith")
            author(name: "Peter Ledbrook")
         }
         book(title: "Griffon in Action") {
            author(name: "Andres Almiray")
            author(name: "Danno Ferrin")
            author(name: "Geertjan Wielenga")
         }
      }
   }
}

Task 1 is completed by calling addVertex on the publishers Graph using a special variable available to all FactoryBuilderSupport based builders: current. This variable points to the node that is currently being built, in our case, the publisher node. Task 2 is completed by changing the strategy used by the builder to set the parent/child relationships within nodes. Notice that it still calls the old behavior by keeping a reference to the previous strategy, then calls a Graph method on publishers that registers the child with its parent. Now both the object graph and the Graph are in sync. The following code shows how the publishers Graph can be visualized with minimal effort:
Running the application should result in a screen similar to the following snapshot

Time to get fancier with the visualizations. JUNG allows you to tweak almost every aspect of a visualization, we will concentrate on shapes and colors for now. It can be argued that visualization metadata belongs or not to domain classes. For example we could add shape and color properties to our domain classes, but perhaps those properties do not make any sense should our domain classes be persisted. In the end is your call how you want to add such metadata. In this howto I'll simply wrap each domain instance with a map, have the metadata (or spillover properties) be added to the map and the corresponding bean properties to each bean. In order to do that we must tweak two other OGB strategies, as shown next on the app's model:

import java.awt.Color
import edu.uci.ics.jung.graph.Graph
import edu.uci.ics.jung.graph.DelegateTree

class BooksModel {
   Graph publishers = new DelegateTree()

BooksModel() {
      def ogb = new ObjectGraphBuilder()
      def newInstanceResolver = ogb.newInstanceResolver
      ogb.newInstanceResolver = { klass, attributes ->
         [bean: newInstanceResolver.newInstance(klass, attributes)]
      }

ogb.addAttributeDelegate({ builder, node, attributes ->
         attributes.each { k, v ->
            try {
               node.bean[(k)] = v
            } catch(MissingPropertyException mpe) {
               node[(k)] = v
            }
         }
         attributes.clear()
      })

def childPropertySetter = ogb.childPropertySetter
      ogb.childPropertySetter = { parent, child, parentName, childName ->
         childPropertySetter.setChild(parent.bean, child, parentName, childName)
         publishers.addChild("'${parent}' - '${child}'", parent, child)
      }

ogb.publisher(name: "Manning", color: Color.GREEN) {
         publishers.addVertex(current)
         book(title: "Groovy in Action", color: Color.CYAN) {
            author(name: "Dierk König")
            author(name: "Guillaume Laforge")
            author(name: "Paul King")
            author(name: "Andy Glover")
            author(name: "Jon Skeet")
         }
         book(title: "Grails in Action", color: Color.RED) {

author(name: "Glen Smith")
            author(name: "Peter Ledbrook")
         }
         book(title: "Griffon in Action", color: Color.BLUE) {
            author(name: "Andres Almiray")
            author(name: "Danno Ferrin")
            author(name: "Geertjan Wielenga")
         }
      }
   }
}

The two strategies are

newInstanceResolver - takes care of instantiating a node. This is the perfect time to wrap the bean with a map.
attributeDelegate - this strategy takes care of setting properties on a node. By testing for MissingPropertyException we know the property may or may not be supported by the bean. If it is not supported we assume it is a metadata property and add it directly to the enclosing map.

Lastly we need to update the childPropertySetter strategy as the beans are now being wrapped. Now that the model has the desired metadata it is time to update the visualization code with a set of transformers. Given that the beans are now wrapped the ToStringLabeller will yield weird results, we need to provide a new value for vertexLabelTransformer. Two new transformers will be added:

vertexShapeTransformer - takes care of setting up the shape to be used for each node.
vertexFillPaintTransformer - takes care of setting up the color to be used as the fill for each node.

We will rely on jSilhouette's Star shape and a helper BasicVertexShapeTransfomer provided by the JUNG plugin. At this point only Books will have a custom shape (the Groovy star ) while the other domain classes will use a circle.

import edu.uci.ics.jung.visualization.renderers.Renderer
import org.apache.commons.collections15.Transformer
import org.apache.commons.collections15.functors.ConstantTransformer
import java.awt.Color
import java.awt.Shape
import java.awt.geom.Ellipse2D
import org.kordamp.jsilhouette.geom.Star
import griffon.jung.visualization.decorators.BasicVertexShapeTransformer

vertexLabeler = { v -> v.bean.toString() } as Transformer
vertexPainter = { v -> v.color ?: Color.WHITE } as Transformer
shaper = { Map shapes, v ->
   shapes[(v.bean.class.name)] ?: new Ellipse2D.Double(0, 0, 1d, 1d)
}
bean(id: "star", new Star(), or: 40f, ir: 20f, count: 5i)
bean(new BasicVertexShapeTransformer(shaper.curry([(Book.name): star])),
     id: "vertexShaper", sizeTransformer: new ConstantTransformer(40i))

application(title: 'Groovy Books',
  pack:true,
  locationByPlatform:true,
  iconImage: imageIcon('/griffon-icon-48x48.png').image,
  iconImages: [imageIcon('/griffon-icon-48x48.png').image,
               imageIcon('/griffon-icon-32x32.png').image,
               imageIcon('/griffon-icon-16x16.png').image]) {
  visualizationViewer(model.publishers, id: "gview", preferredSize: [550,550],
       vertexShapeTransformer: vertexShaper,
       vertexFillPaintTransformer: vertexPainter,
       vertexLabelTransformer: vertexLabeler) {
    radialTreeLayout()
    defaultModalGraphMouse()
  }
  gview.renderer.vertexLabelRenderer.position = Renderer.VertexLabel.Position.CNTR
}

Reviewing each transformer yields:

vertexLabeler - queries the node's bean. v is of type Map.
vertexPainter - queries v's color property, uses a default color (WHITE) if no property is defined. The elvis operator becomes quite handy here.
shaper - another elvis enabled transformer, this one checks for the existence of a shape related to a class name.
vertexShaper - relies on the previous transformer to determine which shape will be used by each node. Notice that only books define a specific shape.

This is all that there is to it. Running the application should result in a similar screenshot like the following one

There you have it, a simple yet effective way to build and visualize an object graph with ObjectGraphBuilder and Griffon/JUNG.

Keep on Groovying!

Some Thoughts on Time

Rob Williams — Mon, 16 Nov 2009 17:57:14 -0500

Time is still something of a taboo in management. When people start talking about tracking time, most developers start getting wound around the big brother axle. Having just looked at Cédric's post about Agile this morning (rare case of cluelessness), to me, the big problem in agile is like all big tents (for instance, the Democrats), we are waking up to the painfulness of a world where there is little consensus. Mind you, even where there are areas of considerable consensus (testing), that consensus is (again, like the Dems) a. broadly prescriptive ('testing is good for you') and b. promoted through fear and guilt (Uncle Bob now refers to code that doesn't have 100% coverage as 'shit' (I literally thought about doing a whole post on just parsing out that idea, and the ugly fascistic implications of promoting a shit-free world, as the various fascisti of the 30s did, in violently rebutting positivists, but I'll keep that for later.. suffice it to say things are starting to get ugly..)). Meanwhile, last week I heard that the Kanban rash is also taking on a fundamentalist flavor: apparently the newest kanbanists believe that estimates and time in general ought be completely banned from management. The rationale goes that estimates are a waste (raises the interesting philosophical question: does Lean, when turned on itself, decide that doing anything is waste, and therefore, the reductio ad absurdum ends up being that the process must inevitably deconstruct, then dispose of itself!!). (See below for some links to read on this.) Anyway, personally our group has found planning poker to be immensely useful. I agree with the first comment on link 1: estimates are not just about getting an estimate. Complexity is the enemy combatant and planning poker does more than anything I‘ve found to get people to focus on that before engaging.

Back to time: I was applauding the emergence of Lean as one of the key spokes in the Agile wheelhouse, but now, with the new ugly kanbanists becoming dominant, I am thinking perhaps we are all going down in the middle of ocean while our hijackers chant kumbaya. People, the core of Lean is the VSM. How does one evaluate the areas that can be improved (kaizen, Baby) without time as the driving factor? Let‘s remember, the problem ecosystem here consists of the triangle: time, resources, features. So we just pushed a piece through, now it‘s done. We can‘t talk about time. What should we talk about? Features? People?

This brings up an issue that might be the fulcrum here: whether or not the team thinks abstractly. If the answer is no (and, unfortunately, it is most of the time), I would submit that any retrospective analysis is a waste. Why? Because it‘s going to end up in the 5 year old, Quincy, Cartoon Coroner, breathless realm of ‘then Tweetie flew through and Sylvester got his tail jammed in the door.‘ The only useful analysis would consist of things like ‘moving to building in place on piece x slowed things down, how could we have built a test case instead?‘ or the like.

What I like about Kanban is that it fits the ABC model well: Always Be Closing. (Read an article the other day that was hailing Mamet and another cat came on and proclaimed him one of the most overrated guys in history. It‘s hard to argue that his oevre can compare to others, but some people get points for ringing the bell, which “Glengarry Glen Ross” does pretty convincingly.) It is a good idea to focus on why things are not moving, what it will take to move them, push them off, etc. To the exclusion of all other things? Not for me. I am going to start fiddling with kanban, but as a way to see where things are and what it will take to push things.

Frankly, I want to get better tools for tracking time. Did an eval of Rally and decided it was the best of what was out there, decided to use it, but then found, to our horror, that their product is built around putting in estimates and actuals, etc., yet it is unable to produce the simplest time reports Found out they are doing a brand new time tracking module which was in beta but then was going to be release first week of Nov. Suddenly it's not coming until middle of Dec! (Guess the whole release missed the train; real Agile there, guys, there are not supposed to be empty trains.. ?) Anyway, that's not even the worst of it. The horribly lacking reports they do have are, get this, obtained by culling numbers from the change logs on each task Among other reasons this is a horrible idea, if you go enter a task and while entering it, put in hours, those will never make it to your report for the month! (I kind of liked this when I discovered it, as it penalizes people who wait to report until they are done, but come on!)

If the whole idea of Lean is to track waste and figure out how to reduce it, ignoring time seams utterly insane to me. The definition of waste is that the time expended did not deliver the desired result. The question is then why. Here‘s the time quiz for the day: where did the convention of surgeons having implements fetched for them by a nurse come from? Early photographer did a time study of surgery and found that people were dying while surgeons were fiddling around on instrument tables looking for things. One imagines that these new time-free kanbanists might favor time tracking of this sort if they were the meat on the surgeon‘s slab.

The (Weak) Case Against Estimation

Opt Out of Google

David Gilbert — Mon, 16 Nov 2009 17:00:31 -0500

Great new opt-out feature from Google:

http://www.theonion.com/content/video/google_opt_out_feature_lets_users

Mobile GPS Navigation App with JSF

Cagatay Civici — Mon, 16 Nov 2009 04:25:30 -0500

There's no limit in what you can do with PrimeFaces.

http://cagataycivici.wordpress.com/2009/11/15/mobile-gps-navigation-app-with-jsf/

QOTD

robert burrell donkin — Sun, 15 Nov 2009 06:53:21 -0500

"Is it automated?"
"Yes, for a loose definition of automated. There's someone who knows what to type in."

Thanks to Steve Loughran

JRoller

CA's Open Source Farce

Downloading CSV, Excel files in GWT

Dual licensing has a bad influence on MySQL future (more generally, on open source too)

spring-json view 1.2.1 added to maven 2 repository

Given, When, Then and how not to do it

The GIVEN clause

The WHEN clause

The THEN clause

Online text to speech application Japplis Speech 1.2 has been released

XenonDataGrid M4.0, Nelson Framework *WIP*

XenonDataGrid M4.0, Nelson Framework *WIP*

Release Notes

My interview with developerWorks

Desperate Binding Module in Swing

Session Handling in GWT

PrimeFaces 1.0.0.RC Released

Thinking of systems

More detail on Closures in JDK 7

Closures in JDK 7

Summary

S1 Java di Universitas Gunadarma, program jTechnopreneuer dan Program jTechnopreneur 1 tahun (Cakra)

Devoxx 2009 Xenon Data Grid Presentation Slides

Devoxx 2009 Xenon Data Grid Presentation Slides

XenonDataGrid Open Source JavaFX Table Component

Abstract

Creating (another) Firefox Theme

Devoxx 2009 Digital Media Report

Devoxx 2009 Digital Media Report

UStream TV Devoxx JAVAWUG Link-Up Show

Incredible Announcements and The Vector of Progress Continues Unabated

Conclusions

The Shout Outs!

JDK7 notes from Devoxx09

Fedora 12

Why JSR-310 isn't Joda-Time

Joda-Time as JSR-310?

Summary

Systems Thinking and Maxis

JAVAWUG BOF 52 What is Oracle Doing With Java?

JAVAWUG BOF 52 What is Oracle Doing With Java?

Headline Talk

Support Talk

Biography

Registration

Media Copyright Notice

Graphing, Django, pyjamas... random thoughts

ReentrantLock Bug?

IBM WebSphere eXtreme Scale 6

Selecting Web Technologies from Devoxx09

Closures in JDK 7

Closures in JDK 7

Grails/Griffon stats trick

Ripped out aggdraw... went back to plain PIL

California Bans Energy Hogging TVs

Abstracting the canvas from the drawing logic (continuation of last blog)

Grails was so electric, it brought down the power grid

Our Devoxx 2009 Talk on Google Appengine Was a Blast

TuneUp: What is So Hard About Cleaning Up ID3s?

Revisiting PyUnit Once Again

Griffon: Scala & Clojure updates

Notes on creating GIF, PNG images in Python (first note) with PIL and aggdraw

ICEfaces Tag Reference

Spring 3.0 REST example

Spring XML Configuration

Domain objects

DAOs

Controller

web.xml

Jetty & RESTClient

Conclusion

XMLHttpRequest to server side by pure javascript

Joda-Money 0.5

Joda-Money 0.5

First experience with Go

Spring Roo JaxItalia Slides

Spring Best Practices JaxItalia Slides

Spring 3 JaxItalia Slides

Griffon: visualizing an object graph

Some Thoughts on Time

XenonDataGrid M4.0, Nelson Framework WIP

XenonDataGrid M4.0, Nelson Framework WIP