[r-t] Roan (software)

[Don Morrison]

Apologies that this will probably only be of interest to at most a few of
you, if any; it still seems worth posting, just in case.

While I've been tinkering with software for ringing for over forty years,
it's always been an undocumented, and untidy, pile of whatever it is I've
needed for whatever has my attention Right Now. It's long been a goal to
act like a good neighbor and tidy things up and document them, and make
them available for others to use. I've finally made some progress on that
front.

As you'd expect, underlying all the various things I've played with over
the years is a library of lower level stuff defining rows and methods and
things like that. Like much of the stuff built on top of it it's gone
through many generations. I've rewritten it at least seven times, and in
several different programming languages. A few generations ago I even gave
it a name, Roan. This is the first part I've tidied up and documented, and
have now made publicly available.

That's the good news. The perhaps not so good news, depending upon your
tastes, is that it is written in my native tongue, Lisp, a programming
language not quite as popular with others as I believe it should be. But if
you are a Lisp hacker, or are willing to put aside your prejudices against
parentheses, perhaps it will be of some use or amusement.

The manual can be viewed at

https://bytebucket.org/dfmorrison/roan/wiki/roan-manual.pdf

If you have a Lisp implementation in which Quicklisp (http://quicklisp.org)
is installed you can download and install Roan by simply evaluating in Lisp

(ql:quickload :roan)

The sources and other presentations of the manual (PDF, HTML, Info) are at

https://bitbucket.org/dfmorrison/roan

While there are no large, didactic examples included yet, there's a
reasonably rich set of unit tests that may serve as stopgaps. And, as those
who know me would expect, the documentation is prolix, and full of brief
examples.

It's released under a highly permissive license (the MIT License) so you
can pretty much do with it whatever you like.

It is roughly at the level of Martin Bright and Richard Smith's Ringing
Class Library (http://ringing-lib.sourceforge.net), though obviously in a
different programming language and differing from that library in myriad
other ways.

Besides underpinning much of what I use for composition and so on, it is
also what drives most of the methods stuff on ringing.org.

Among its features are:

• facilities for representing rows and changes as Lisp objects, and
permuting them, etc.

• functions for reading and writing place notation, extended to support
jump changes as well as conveniently representing palindromic sequences of
changes

• a set data structure suitable for collecting and proving sets of rows, or
sets of sets of rows

• a pattern language for matching rows, for example, for identifying ones
with properties considered musically desirable; and that includes the
ability to match pairs of rows, which enables identifying wraps

• a data structure for describing methods, which can include jump changes

• a searchable database of method definitions, together with a mechanism
for updating that database from the ringing.org web site

• a function for extracting false course heads from common kinds of methods

I'm still tidying up other bits and pieces and hope to make them available
in future versions of Roan, as well as in one or more projects built on top
of Roan.




-- 
Don Morrison <dfm at ringing.org>
"Unraveling evolutionary mysteries is generally hard work, the stuff
of long careers spent in careful thought and observation. But some
stories are obvious, crystal clear from the very beginning. Anyone
familiar with children, for example, understands the origin of
punctuation. It started with the exclamation point."
       -- Thor Hanson, _The Triumph of Seeds_
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.ringingworld.co.uk/pipermail/ringing-theory/attachments/20170702/5426e8b3/attachment.html>