To include it into your Maven POM you’ll have to add my repository to a profile in your settings.xml:

<repositories>
  <repository>
    <id>crazy-mcphee</id>
    <url>http://modular.autonomous.org:80/artifactory-2.0.5/libs-releases-local</url>
    <snapshots>
      <enabled>false</enabled>
    </snapshots>
    <releases>
      <enabled>true</enabled>
    </releases>
  </repository>
</repositories>

At which point you can include the dependency in your pom.xml for your project:

<dependency>
  <groupId>org.autonomous</groupId>
  <artifactId>money-is-money</artifactId>
  <version>0.17</version>
</dependency>

If you want to check the source code out with SVN the release is at http://crazymcphee.net/svn/money/tags/money-is-money-0.17 and the latest trunk at http://crazymcphee.net/svn/money/trunk

In recent times I’ve seen this often enough that I think it’s really a failing of the IT industry in general, and we need to educate business IT users about the various scenarios and categories of software.

The simplest analogy I can think of is to say the website or portal is the letter, and the platform is the word processor.  Regardless if you use Word, Wordperfect, Pages 09, your email program or just plain old ‘notepad.exe’, at the end of the day the time to write the letter is pretty much the same effort and therefore the task is basically identical. If you said “I want you to help me to write a letter to my member of parliament”, should  I ask you whether you’re using the new letter wizard in Word? Have you seen this great “clippy” feature? Have you considered the new upgrade to Office 2007? Tell you to buy a Mac? Or would I be better off asking who is your member of parliament and what’s the matter about? When we get these sorts of naive clients we need to concentrate their minds on what their actual problem is and the best way we can solve it, when they’ve got their head in the sand thinking about that great drag-and-drop wizard feature the vendor showed them they totally thinking about the completely wrong thing.

The basics of Tapestry is that it is a component-based web framework. Just about everything, including web pages, are components. Components may contain other components. The way it works is very simple and quite elegant, once you get used to it and weaned off the big-XML-file style of configuring a web application.

When you start, you have two main Java packages that are created for you (if you use the maven archetype, otherwise you will create these packages yourself). If your package root is say “net.crazymcphee.webapp”, then your two packages are “net.crazymcphee.webapp.pages” and “net.crazymcphee.webapp.components”. To configure a Tapestry 5 project with maven use this command and answer the prompts:

mvn archetype:generate \

    -DarchetypeCatalog=http://tapestry.formos.com/maven-snapshot-repository

Don’t use the one in the tutorial as it will not work! This is an excellent illustration of the first and most serious problem that Tapestry 5 has: the documentation not only has massive lacunas, it is also sometimes wrong and not updated.

Now, any class that you create in the “pages” package will automatically become a page in your application. But these classes need not be very complex at all. For example:

package net.crazymcphee.webapp.pages;
 
import java.util.Collections;
import java.util.List;
 
import org.apache.tapestry5.annotations.Persist;
import org.apache.tapestry5.annotations.Property;
import org.apache.tapestry5.ioc.annotations.Inject;
 
import net.crazymcphee.webapp.model.Person;
import net.crazymcphee.webapp.services.PersonService;
 
public class Persons {
 
    @Inject
    private PersonService personService;
    @Property
    @Persist
    private List persons;
    @Property
    @Persist
    private String searchTerm;
 
    Object onSubmitFromSearch() {
        persons = personService.findPersons(searchTerm);
        return this;
    }
 
    Object onSubmitFromClear() {
        persons = Collections.EMPTY_LIST;
        return this;
    }
 
}

You can see that this class doesn’t extend any infrastructure classes and has quite a simple structure. This is a fully functional page with two actions – one populates a list, the other clears it.

Now, to explain just a little here; PersonService is injected by Tapestry, but you need to configure in your AppModule which implementation you want to use. You can also use it with Spring as your IOC container but the one that comes with Tapestry is perfectly good enough for most applications.

The List, persons, and the searchTerm parameters are marked as @Property (so we don’t need to add getters and setters) and also @Persist so that the variables are preserved from request to request.

The methods “onSubmitFromSearch” and “onSubmitFromClear” are using a convention – “onSubmit” will also work, but assuming (as is true in this case) that we may have multiple forms on the one page, each method will only be fired from the “search” form in one instance, and the “clear” form in the other. These names are not special, it’s just (as you’ll see below) the forms will have these two names. They could be “Bill” and “Ben” in which case the methods would be “onSubmitFromBill” and “onSubmitFromBen”.

You will also note that these methods return the same page instance, which tells Tapestry to re-render the same page, but if you wanted to forward onto another page, you would add a instance variable, mark it with an @InjectPage annotation, and return that instance variable (after initialising it in your “onSubmit” method) instead of just returning “this”.

This page Persons, is available at {application-context-path}/persons. But there is one other part of the puzzle – the actual view. As mentioned, Tapestry uses convention over configuration and in this case, the convention is that the Page markup must be named the same: Persons.tml. Here is the matching tml file for the class above;

<html t:type=“layout” title=“Peoples I Might Know”

t:sidebarTitle=“Current Time”

xmlns:t=“http://tapestry.apache.org/schema/tapestry_5_1_0.xsd”

xmlns:p=“tapestry:parameter”>

<!– Most of the page content, including <head>, <body>, etc. tags, comes from Layout.tml –>

<t:form t:id=“search”>

<t:textfield t:id=“searchTerm” validate=“required” size=“20″/>

<t:submit t:id=“searchPeople” value=“search”/>

</t:form>

<t:grid source=“persons”/>

<t:form t:id=“clear”>

<t:submit t:id=“clearPeople” value=“clear”/>

</t:form>

</html>

Yes, it’s that bloody simple. The first form fires the “onSubmitFromSearch” method (with a little bit of validation, done in javascript) and the second method clears the list. In-between, there is this <t:grid source=“persons”/> business, which, if the ‘persons’ variable in the page class is populated, will show a list of its contents!

To test our app, we can use the command-line ‘mvn clean jetty:run’. When Jetty has run up, then we can point our browser at the web app: http://localhost:8080/sample-webapp/Persons, and with any luck we will see the following:

Now, by default, Tapestry creates the web app to use the template design as shown above. Of course, you can make it look completely some other way – or even use a totally different template if you want. The page template is just a component that’s included.

So if you enter in a search term and click the search button, you’d expect to see a result like this:

As you can see, the list is automatically populated with the details returned from the service method (in this particular instance, this are just a canned response, but normally of course they’d be the result of a database or a web service call of some type).

When you click the clear button, the list is cleared as you’d expect:

Now, here’s a really powerful feature I find in Tapestry. Let’s say our automated acceptance tests assert that when the ‘Clear’ button is pressed, the Search box as well as the persons list is cleared. What Tapestry allows us to to do, is keep Jetty running, edit the files in the IDE, and re-run the tests against the running app without restarting! We edit our method:

    Object onSubmitFromClear() {
        persons = Collections.EMPTY_LIST;
        searchTerm="";
        return this;
    }

In this case I’ve also added a bit of space around the clear button in the template as well:

And now our failing test will pass.

Editing files like this in the running web app only works for Pages and I think Components. If I had to change the service or model classes I’d have to restart, but “mvn jetty:run” isn’t very a heavyweight process.

As I said above, Tapestry’s not perfect: it’s major flaw is the poor documentation. Convention-over-configuration is easy to grok – if you know the convention. If you don’t and the documentation doesn’t tell you, and you can’t find a sample of what you need, it can be very frustrating. There is an excellent user list though.

Its other major flaw may be the stability of the API. Tapestry 5 is different (and incompatible) from Tapestry 4 is different from Tapestry 3. But so far I’ve used it on a couple of projects and I’m really enjoying it. I really hate the oodles of XML boilerplate and massive amounts of configuration found in Spring and I find myself somewhat reluctant to use it unless I really have to. Tapestry solves for me a range of different problems and mostly it presents a very elegant way to create a componentised web application. You might like to give it a try.

Attached is the sample code used above. It took me about 10 minutes to write (far shorter than it took me to write this blog entry!) - sample-webapp.tar bundle

You can manually browse the artefacts in the repository here.

Here’s the updated README:

This package is copyright 2008-2009 Scot Mcphee.

Email: scot.mcphee at gmail.com

Licence is the M.I.T. Licence. Please see the file “LICENCE”.

WHAT IS Money-Is-Money?

Money-Is-Money is a library for the correct manipulation of monetary data. I wrote this small library because I found that there were not any available public source Money implementations, despite some Time-based libraries promising such (I guess Time is more interesting to programmers than filthy lucre).

It consists primarily of an interface, called ‘Money’, and a Factory for making money, called ‘MoneyMaker’. There is a single implementation classes, MoneyAmount.

Money uses BigDecimal throughout to represent values. Yes, that’s a java.math.BigDecimal. If you whine about wanting to use doubles and floats congratulations! You are the target audience and therefore you should *really* be using this library and I won’t go into debate here why it’s wrong to use floating point logic in Money implementations.

Money is designed to be an immutable object. All operations on Money, such as Money.add(Money) returns a new instance of Money representing the added amounts. There are operations for add, subtract, divide, and multiply. The default rounding mode is HALF_EVEN or ‘bankers rounding’. If a value comes out to 0.5, it is rounded to the EVEN value, so $3.555 at a precision of 2 decimal places becomes 3.56, and so does $3.565. Divide and multiply also include methods to perform those operations with a user-specified rounding mode. There are also methods to do high-precision “no rounding” division and multiplication (dividePrecise and multiplyPrecise), which will throw an ArithmeticException if the decimals cannot be terminated and therefore have no decimal representation, e.g. 10/3, so be careful in using it.

There is also two methods to ‘proRate’ money. The first takes the existing money and divides it up as equally as possible into the number of buckets you specify, with the modulo distributed in as small as increments as possible across as many of the buckets as possible.

This is NOT THE SAME as dividing by the number you specify. So $10.00 divided into 3 buckets results in buckets containing $3.34, $3.33, $3.33. The specification is that adding the buckets back up should always result in the original amount without any rounding errors. You should be able to pro rate an amount, then pro rate those amounts, recursively many many times and adding up all the ‘leaf’ values will result in EXACTLY the original amount.

There is an additional method of ‘proRate’. That is the weighted pro-rate, proRateWeighted. It allows you divide a money amount into a number of buckets with each amount weighted according to a value in an array. E.g. an array of {1, 2} divides the amount into 2 buckets, the first one having 1/3 of the amount, the second 2/3. This can get much more complex than that simple example, e.g. consider $54 divided by the weights {1, 1, 2, 3, 5, 8, 13, 21}. Well in that case I am cheating because the amounts returned would be {1, 1, 2, 3, 5, 8, 13, 21}, but consider some random amount, let’s say $9824516.53 divided by that same array of weightings. The weightings have to be obeyed and the numbers must all add up at the end. This implementation was supplied by my friend and former colleague Tim Eagles and refined a little by myself.

The current implementations of both the ‘proRate’ methods take the remainder R and distribute it amongst the *first* R elements of the (weighted or un-weighted) buckets. Thus, the earliest elements may be out by 1 cent (or 1 whole Yen) compared to a straight floating point division of value divided by number of buckets.

If you find this library at all useful, or have improvements and suggestions, drop me a line at scot.mcphee@gmail.com

Please remember to shake your MoneyMaker.

In the course of all this testing though I thought it best to use it in something like real anger with the Maven release plugin rather than my rather artificial usage scenario I was building up between my two development machines.

As a result of all that I’ve released a version of my Monetary library, money-is-money. The version is 0.15 and the Maven repository for it can be found at http://modular.autonomous.org:80/artifactory-2.0.5/libs-releases-local

If you want to check the source code out with SVN out the release is at http://crazymcphee.net/svn/money/tags/money-is-money-0.15 and the latest trunk at http://crazymcphee.net/svn/money/trunk (which at the time of writing is the same as the release of course, except it generates 0.16-SNAPSHOT).

To include it into your Maven POM you’ll have to add my respository to a profile in your settings.xml:

<repositories>
  <repository>
    <id>crazy-mcphee</id>
    <url>http://modular.autonomous.org:80/artifactory-2.0.5/libs-releases-local</url>
    <snapshots>
      <enabled>false</enabled>
    </snapshots>
    <releases>
      <enabled>true</enabled>
    </releases>
  </repository>
</repositories>

At which point you can include the dependency in your pom.xml for your project:

<dependency>
  <groupId>org.autonomous</groupId>
  <artifactId>money-is-money</artifactId>
  <version>0.15</version>
</dependency>

After that Maven should fetch the artifact from my repository automatically for you. Money-Is-Money is deliberately designed to void any external dependencies on anything other than Java libs, except for JUnit which only matters if you want to build from source. For more information please see this post.

It’s still a work in progress. You can check it out with SVN from http://crazymcphee.net/svn/money/trunk/

From the README:

This package is copyright 2008-2009 Scot Mcphee.

Licence is the M.I.T. Licence. Please see the file “LICENCE”.

WHAT IS Money-Is-Money?

Money-Is-Money is a library for the correct manipulation of monetary data. I wrote this small library because I found that there were not any available public source Money implementations, despite some Time-based libraries promising such (I guess Time is more interesting to programmers than filthy lucre).

It consists primarily of an interface, called ‘Money’, and a Factory for making money, called ‘MoneyMaker’.  There are a number of implementation classes, primarily CashMoney and  PrecisionMoney. They both share a abstract implementation, AbstractMoney. For the time being. I can see ways to eliminating both and just having a single implementation of the Money interface, but I haven’t done it yet.

However, for the time being, CashMoney is used whenever MoneyMaker is given a Currency (that’s java.util.Currency)  which has a default scale less than the given BigDecimal’s scale. Yes, that’s a java.math.BigDecimal. If you whine  about wanting to use doubles and floats congratulations! you are the target audience and therefore you should *really* be using this library and I won’t go into debate here why it’s wrong to use floating point logic in  Money
implementations.

Money is designed to be an immutable object. All operations on Money, such as Money.add(Money) returns a new instance  of Money representing the added amounts. There are operations for add, subtract, divide, and multiply. The default rounding mode is HALF_EVEN or ‘bankers rounding’. If a value comes out to 0.5, it is rounded to the EVEN value,  so $3.555 at  a precision of 2 decimal places becomes 3.56, and so does $3.565. Divide and multiply also include methods to perform those operations with a specified rounding mode.

There is also a method ‘proRate’. This takes the existing money and divides it up into the number of buckets you  specify, with the modulo distributed in as small as increments as possible across as money of the buckets as possible. This is NOT THE SAME as dividing by the number you specify. So $10.00 divided into 3 buckets results in buckets containing $3.34, $3.33, $3.33. The specification is, adding the buckets back up should always result in the original amount without any rounding errors. You should be able to pro rate an amount, then pro rate those amounts, recursively many many times and adding up all the values will result in EXACTLY the original amount.

If you find this library at all useful, or have improvements and suggestions, drop me a line at scot dot mcphee at gmail dot com

Please remember to shake your MoneyMaker.

Sun Microsystems is getting some love from Wall Street after its sales and earnings topped estimates, as detailed by Bloomberg. Software sales jumped 21 percent year-over-year.

What is fueling the growth? The same thing that Sun CEO Jonathan Schwartz has doggedly said would lift Sun’s fortunes again: open source.

via Open source makes Sun’s quarter shine | The Open Road – CNET News.

If this approach is validated going forward the next year or two, will it change the software industry radically? Quite possibly. Remember this is not a five-man company selling training and consultancy services leveraged off it’s founders’ successful open source software effort, nor even a much larger company set up solely to market and sell services and support contracts based around packaged open source distributions. Sun is a big vendor, which has had to turn its ship of business around almost 180 degrees to get where it’s going now. And maybe, just maybe, it’s on a winning course now.