[Haskell-cafe] [ANNOUNCE] Penny - double-entry accounting

[Omari Norman]

I'm pleased to make the first public announcement of the availability of
Penny, a double-entry command-line accounting system.

Penny is inspired by Ledger, an excellent program in its own right.
Ledger's websites and sales pitches are much better developed than those
for Penny, so first take a look at Ledger's website to see if the concepts
behind this program interest you:

http://www.ledger-cli.org/

With that in mind, here is what distinguishes Penny from Ledger:

* Smarter report formatting. When using Ledger I rarely bothered to
reformat the reports because I could never remember how to use the cryptic
formatting strings.  Penny automatically formats reports to fit the width
of your screen.  You can easily add or remove information in your reports.

* Use of color.  Color is baked into Penny, making reports easier to read.
It takes advantage of 256-color terminals where available.

* Adherence to double-entry accounting principles.  Ledger will allow you
to enter unbalanced transactions.  Penny never allows this.  Even
infinitesimally unbalanced transactions will render your entire ledger
invalid.

* Different handling of commodities.  In part because of the strict
adherence to double-entry accounting principles, Penny handles commodities
(e.g. transactions involving multiple currencies, or currency and equities)
differently than Ledger.  Some might regard Penny's handling of commodities
to be a pain, but I think it results in a system that is more predictable,
has no corner cases, and is easy to test.

* More orthogonal command-line interface.  For example, in Ledger, you use
one set of options to filter postings by date, and a different set of
options to control the dates of postings that are shown in the register
report.  Penny uses identical options for these two purposes; what these
options mean depends on where they appear on the command line.  In
addition, in Penny you can build filtering expressions of arbitrary
complexity, using either infix or reverse polish notation.

* Automated import of postings.  You can import postings from your bank as
long as it gives you OFX files. Many financial institutions supply OFX
files, as it is the format used by Quicken and by the now-defunct Microsoft
Money.  Penny can also help automate a great deal of the process of
reconciling your ledger with bank statements.  This removes an enormous
amount of the drudgery that is associated with maintaining a ledger.

* Exposes a Haskell API.  This is actually the primary reason I wrote
Penny.  I run several automated checks on my ledger.  Doing this in Ledger
was growing difficult because I had no standalone parser for the ledger
files.  With Penny I can easily write additional small programs to check up
on the consistency of my ledger (for instance, to make sure I'm not using
invalid accounts, or to make sure that a particular account has postings
within a given time period.)  The power of Haskell makes this much easier
than it would be if I used a dynamically typed language like Haskell or, as
I used to do with Ledger, a random assemblage of shell, Awk scripts,
Haskell, and more.

Another child of Ledger that is written in Haskell is hledger:

http://hledger.org/

hledger is a great program; if you like it, please continue using it.  In
addition to what you can glean from the bullets above, here are some key
ways Penny differs from hledger:

* hledger is at least partially compatible with Ledger; Penny is
incompatible with Ledger.  There currently is no program to convert Ledger
files to the format Penny uses (I once wrote such a program to convert my
Ledger files to Penny; after that the program was of no use to me and the
file format has since changed, rendering that code useless.)

* hledger has a web interface.  Penny does not and I doubt it ever will.

* hledger has a robust community; Penny does not.

* hledger supports more of Ledger's feature set with features such as
timelog support, periodic reports, and balance assertions.  Penny does not
have these features.

* hledger uses floating-point types to represent amounts:

http://hackage.haskell.org/package/hledger-lib-0.21.3/docs/Hledger-Data-Types.html#t:Quantity

Penny uses only integers:

http://hackage.haskell.org/package/penny-0.30.0.0/docs/Penny-Lincoln-Bits-Qty.html

This page summarizes why that matters:

http://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency

* Penny is BSD3; hledger is GPL.

And an entirely subjective comparison that may be biased: Penny is designed
from the ground up to use Haskell's static type system and its module
system to its maximum advantage, which makes Penny easier to use as a base
for your own programs to check your ledger, and which reduces bugs.

Penny has been in development for over a year now, and I use it to maintain
my financial records.  A set of QuickCheck tests, in conjunction with
maximum exploitation of Haskell's static type system, help ensure the
correctness of the code.  However, as with all free software, Penny comes
with no warranty.  Use it at your own risk.  Please report any bugs you
find in the programs or the documentation to omari at smileystation.com.

Penny is written only for UNIX-like operating systems.  Currently it should
build against Haskell Platform 2013.2.0.0.  If it doesn't work on your
Linux or Mac OS X system, please let me know.

Get Penny using "cabal install penny" or look here:

http://hackage.haskell.org/package/penny

Website with manpages:

http://massysett.github.io/penny/

Github:

https://github.com/massysett/penny

Enjoy.

Omari
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20131002/1ac7ba9d/attachment.htm>