Old Chart

This is the old version written in Guile.

You'll need Guile (1.6.7 or higher, or 1.8.1 or higher, but 1.6.8 recommended as the 1.8 series has a bad memory leak), Guile Gtk 2.0 or higher, and the Gtk 2 libraries.

Download version 53 here.

chart-53.tar.bz2 (1062k, and sig)

Or packaged for a Debian system, built on a recent "unstable" for Guile 1.6.

chart_53-1_i386.deb (746k, and sig)
libguilegtk-2.0-0_2.0-0.2_i386.deb (319k, and sig)

This libguilegtk-2.0-0 was built from the Guile Gtk 2.0 sources with the following /debian directory:

debian-dir-2.0-0.2.tar.gz (3k, sig)

The sig files above are Gnu PG ascii armoured signatures, generated from my key at savannah. If the dependencies in the .deb are too new or too old then you can try making your own with the usual fakeroot debian/rules binary from the sources.

This upgrade to Perl is a case of "get with the strength", as the Cannanes sing, and the Commonwealth Bank used to say. You might think Scheme is a little cleaner, but it's sprayed across about 10 mutually-incompatible implementations with a bare handful users of each, and lots of incompatibilities between releases. There's plenty to dislike in both Perl and Scheme, but Perl is far better for a medium to large interpreted program.

There's some bits in the sources above that might be of separate interest.

Continuations are about the only feature not covered by Perl (until Perl6). Given how poorly explained the continuation concept is in Scheme you might think that's no great loss! Perl has POE to do equivalent cooperative multitasking, though with the great tedium of writing in state machine style. Cooperative tasking is a bit overrated though, outside of specific communications tasks, since delays in number crunching or database access are very hard to avoid. Throwing jobs down to a sub-process (or a thread if you trust threads) works better.

The object-oriented stuff looks rough in Perl, but it's actually ok, taking a minimal approach of looking up functions in nominated packages. OOP in lisp ends up worse generally. The flexibility of lisp inspires people to try every programming style in it, but for OOP by the time you get macros involved and have to redefine functions to dispatch it gets pretty obscure. A little spot of syntax goes a long way in OOP, to distinguish methods from functions or variables, but which the lisps generally don't introduce.

Threads in both Perl and Guile are pretty disastrous. Guile has endless race conditions (as fundamental as module symbol tables for instance) and doubtful portability bits (such as lacking memory sync on archs like alpha). That was basically where Perl 5.6 was, and which proved unworkable. The Perl 5.8 "ithreads" shares nothing except explicitly nominated variables, which means there's a lot of duplicated loaded code, but it's about the only way to be safe. In any case slave subprocesses end up easier to start and stop etc for things which can be divided into tasks or jobs.

This page Copyright 2009, 2017 Kevin Ryde.
Back to the sitemap.