So you improve fulfillment (improved quality) and customer service (reduced cycle time). Revenue increases. Try proving your improvements were the cause.

You can’t. You can’t even measure customer satisfaction accurately, let alone demonstrate its relationship to increased revenue.

Which is why those who “run a company by the numbers” so often rely on mindless cost-cutting: They can easily prove the connection to this-year bottom-line improvements, while those who complain about the long-term consequential damage have no proof — only their knowledge of and confidence in the business model.

Managing to the numbers | Bob Lewis @ Keep The Joint Running.

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

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.