-Original Message-
From: Alexander Johannesen alexander.johanne...@gmail.com
Sent: Nov 1, 2010 9:33 PM
To: CODE4LIB@LISTSERV.ND.EDU
Subject: Re: [CODE4LIB] Let's go somewhere [was PHP vs. Python...]
...
So this is not a *dumb* idea, nor is it one of simply saying it's the
API, stupid. It does goes deeper than that. Not that you / we should
do it, but that's it a good exercise that should have happened. And,
heck, might even have happened.
Alex explains eloquently the problems and possibilities of a DSL for the
library world, and semantic maps generally. This is also in answer to some of
Patrick E.'s earlier questions about what I am trying to do.
From the readme ( http://www.avantilibrarysystems.com/README.txt ):
Avanti Nova is a general-purpose semantic mapping system. Although first
conceived for use as new kind of library catalog, it can be used in any
situation to dynamically map the relationships in a set of objects.
Some of its core ideas were first used in Avanti MicroLCS, and these
were later generalised and extended in Nova.
Nova is firstly a data structure with a scripting language interface to it.
Programs are written in Nova to create and manage semantic maps.
It also runs as a client-server system, and can be used from other
environments like Unix shell scripts. And since it is written in Java,
it naturally provides a Java API.
The core idea in Nova is to represent a semantic map as a very large array.
This allows for great flexibility in manipulating relationships in
semantic maps.
The README also has some actual examples of programs in the Nova language as it
was a couple of months ago, and all of this stuff works right now, although
there is a long way to go. Simple and crude perhaps, but that's how all things
begin.
I see much potential value in this thing even though much of it could be done
with generic tools. I also believe that the generic tools (or anything for
that matter) become their own mind-prisons if we rely too much on them. Soon
we're speaking and thinking only in Ruby, Python, Perl, Django, Java, MARC or
whatever with all their inherent metaphors and limitations. Pick up a hammer
and everything starts looking like nails. It even goes into more general
things: Everything is an API. We become like the blind men and the elephant.
There are DSLs that serve other domains quite well. Mathematica and R are good
examples. Why not a DSL that speaks the language of semantic maps directly?
Semantic mapping can be a very large and rich domain. A DSL that seperates the
problem from the API, as Alex points out, can handle many problems much more
elegantly and flexibly than APIs or something that's tied to a specific tool's
way of looking at things.
Another line of thought that's a big innovation killer is: Something like this
has been done before, so further work on the problem is not worthwhile.
Carried to an extreme we'd all still be clunking around on wheels chiseled from
stone slabs today because they've always been good enough. MARC is a very
heavy stone wheel that has become a millstone around the neck of the library
profession.
My approach in doing this is to not worry or think too much about what has been
done before. Start fresh with the basic concepts and what makes sense and try
to make something useful out of it, from the ground up. Worrying about what's
been done before leads to copying and a lot of original ideas may get rejected.
If some wheels get reinvented, so what? Reinventing the wheel often leads to
better wheels. Sometimes you have to build something first even if it doesn't
solve a specific problem in order to see its value. I am no expert Nova
programmer yet because I'm still building the thing. There's no community
around this yet. It may be homegrown by a lone developer right now but that's
the way many things start. And besides, as far as doing it goes, what the heck?
Peter Schlumpf
www.avantilibrarysystems.com
