Effective Simplicity

2012.02.22   Web based interface for Nova

Avanti Nova now has a web based interface.

This is a basic easy to use interface that demonstrates the semantic mapping capabilities of Avanti Nova. In this case a simple library catalog is implemented bringing together a database of book title records and related content on the web.

The interface presents a list of objects with the "current" object in red text, followed by the first 30 characters of the objects' content in grey. The objects in black are ones that the current object links to. Along the top: Home, New, Edit, ... are operations that can be done on the current object. The Home object is the reference point. Everything in the interface is clickable. Clicking on an object label makes that one the current, and so forth, traversing the relationship structure. Documents in Nova are displayed as HTML. Any Nova document can link to any other. and these relationship structures are completely independent of the content.

Keep in mind that nothing about the library catalog is hard coded in Nova. It could be set up for many different things. The web interface itself is written as a collection of PHP modules. It talks to the Nova server via socket using its own network application protocol based on the Nova scripting language.

This web interface is a proof of concept and a reference application that can do useful things and that can be extended in many directions. It is not necessarily a "production" application of Nova.

There is a long way to go. Navigating "backward" through structures isn't implemented yet (use the Back button of the browser). Linking and unlinking require that you know the object name you want to link to. Go ahead and try it out, but keep in mind that any objects you create are open for all to see. If you change something that's ok. Delete is currently disabled. Please feel free to tell me what you think. Feedback is welcome! -- pschlumpf@gmail.com

Try it out here.

2012.01.12   A New Year

A new year has arrived, and Avanti Library Systems continues work on Nova, a semantic mapping system. Version 0.2 is in development, which will include a graphical user interface. More news will follow here as it develops.

Focus will continue in providing something useful for the library community as Nova evolves into a universal tool for data mapping in many contexts. Nova databases consist of sets of small pieces of information. These can either be metadata referencing external objects, the data itself, or a mix of both. Nova imposes no particular model of the structure of the data: No rows and colums in tables, or tree like heirarchies. It is a blank canvas for organising information and ideas.

Simplicity is our passion.

2011.11.21   Web based user interface

Currently we are working on a web based user interface to Avanti Nova. More details to follow soon.

2011.08.19   Avanti Nova 0.1 Released

Avanti Nova version 0.1, a generalized semantic mapping system is now released. This version provides the basic foundation for the software, focusing on defining the core Nova scripting language. It also has client/server capabilities, using the Nova language as an application protocol over a network connection. A small demo Nova program implementing a simple library catalog is included. Nova is written in pure Java. The source code is provided. Version 0.1 is a proof of concept of some new ideas and is not meant to be used as a production application; that will come later. If you get this running and try it out, please let me know what you think! pschlumpf@gmail.com

Download: nova-0_1.tar.gz
Documentation: README.txt

2011.08.10   Nova Presentation at Code4lib Midwest Meeting.

On 28 July 2011 the Avanti Nova project was presented at the Code4lib Midwest 2011 meeting at the University of Illinois at Chicago. The current version of the software was also demonstrated. Here are the slides for the presentation.

2011.05.02   Avanti Nova

The Nova programming language defines objects and provides tools for manipulating the relationships between those objects in a semantic map. It borrows ideas from a number of areas. However, it is essentially a new language designed from scratch for the purpose. Very simple and concise, the core operators create, query, and remove pointers from one object to another. Object data types are limited to strings and CSV records.

A little background of how semantic maps are stored in Nova using an example: Consider a set of 10 objects. They can be anything. Then, think of a square 10 x 10 two-dimensional array where columns are the objects and rows are the relationships each object has with all the objects in the set. Each cell in the array has a 1 if a relationship exists. A 0 otherwise. At this level we do not care what the objects are, simply the relationships between them. This array is a database of pure relationships. By flipping the cells in the array from 0 to 1 or 1 to 0 we can manipulate the relationships between objects in the set. This can be queried. If, say, you want to see all the relationships object 3 has with other objects, select row 3 from the array.

To make this thing useful, we map objects to external strings. That provides objects their meaning. These strings can be anything. They could be the text of the objects themselves, or they can reference things in the outside world through URLs or other mechanisms. Rules and protocols can be defined arbitrarily for these strings to make them useful in ways that aren't anticipated by Nova. Then, introduce indexes to make all this searchable. That is the power of Nova. It's a blank canvas -- nothing is hard coded. It's all up to you.

So what we have is a set of objects whose interrelations are completely independent of what they are or what they describe. A pure semantic database independent of content.

Nova today consists of a command line interpreter that implements the language and a client/server architecture to make that language available on a network, similar to the way an SQL database server works. It happens to be written in Java. What it is written in doesn't matter. It could have been written in C or any layer of abstraction sufficient to implement what it does. Simplicity gives the freedom to do all kinds of things. Nova is simple enough where even a computer isn't necessary. A pencil, eraser and paper would work. The computer just makes things easier and scales better. We have to be careful not to let our tools define the way we do things.


Commands and syntax.

Some of these commands and expressions, particularly those that have to do with creating objects and making links, are essential. Others are supporting structures native to this particular environment that may or may not remain.

$a = data
Defines an object with the label $a and sets a value to it. Object names are prefixed with a '$'. For example:

   $peter = "Peter Schlumpf"

The quote marks are optional, so

   $peter = Peter Schlumpf

is valid.

$a
Prints the contents of $a.

$a = $b
This copies $a to $b. So, if

   $peter = Peter Schlumpf
   $peter2 = $peter

   $record = , First_name Last_name