Very often, the main problem with computers and the Internet is not
creation, or even discovery, of data or whole documents; it is to
generally make sense of all those things and, above all, of their more
or less evident connections. Today, I’d like to introduce you to a little piece of free software that tries to make this very task a bit simpler.

An ambitious roadmap

Piggydb is a Java application aiming to become “a
flexible and scalable knowledge building platform that supports a
heuristic or bottom-up approach to discover new concepts or ideas based
on your input.” Quite a mouthful, isn’t it? In plain English, this
means that some day, Piggydb should semi-automatically discover, or at
least make much more visible, connections among pieces of information
that the user didn’t declare or know about when he or she
first fed them to the software. This continuous, ever-improving self
reorganization of data should help users discover new ideas and
generally be more creative.

What does Pigggydb do today?

Don’t let buzzwords and long-term roadmaps mislead you. In its current
state, Piggydb already is an interesting combination of outliner, diary,
notebook and personal wiki. It’s definitely worth a try, in my opinion, by
everybody working with lots of interrelated, mostly textual content.

Installation, architecture, and main features of Piggydb

Piggydb is available as a stand-alone desktop application or as an
“all-in-one” package. The latter is a web server accessible by any
browser, even remotely, and that’s the version I tested and show here.

Both variants will run everywhere Java is available. The installation
procedure on Linux, however, at least for the all-in-one package, is
just a bit more work than it seems from the web site. In order to make
the “” script work as advertised, you need to:

  • save it with Unix-style newlines, instead of DOS ones, with any of these one-liners
  • change its permissions to 755 (chmod 755
  • set it up to start automatically at every boot (this depends on your distribution)

Once the Piggydb server is running, log in to your browser at http://localhost:8080 or whatever URL and port you told Piggydb to use. The default account and passwords are both equal to “owner.”

Figure A
shows how to create the basic building blocks of a Piggydb
knowledge database, called “fragments.” 

Figure A

Fragments are the basic building blocks of a Piggydb knowledge database.

A fragment can be a short note, a
paper abstract, a citation, or even just a link to some local file or
web page. Besides basic formatting and a spelling checker, you get the
possibility to embed other fragments in the current one, as long as you
remember their ID number. 

Figure B and Figure C show this process. By
default, all the Pyggydb data are stored in the $HOME/piggydb folder.

Figure B

Nesting fragments.

Figure C

Nesting results.

Piggydb has tags…

The Piggydb developer rightly points out that, while it is possible, you
really shouldn’t use Piggydb as a traditional wiki — that is, to create
something with one main theme and a single, top-down hierarchy. The real knowledge organization capabilities
of Piggydb lie in two other mechanisms. The first one, shown in Figure
, is Hierarchical Tags. You can create as many tags you want, arrange
them in a tree, and attach them to any fragment.

Figure D

Hierarchical Tags.

…but its relationships are better

As convenient and familiar as it is, tagging is not the best feature of Piggydb. Its other
method to organize information, which (in my opinion) is the most
interesting, may help you a lot — even with very little tagging, or none
at all.

The Piggydb user interface lets you drag and drop icons from one
fragment to another to create relationships between them, as shown in
Figure E

Figure E

Create relationships between fragments.

Each relationship can be mono or bi-directional, and you can
set up as many of them as you want. This produces decentralized networks of fragments instead of simpler tree-like hierarchies, regardless of any tags applied to the same fragments.

The result, if you keep tagging and creating relationships, is something
similar to Figure F: a somehow spartan but complete view of all your
fragments and their interconnections. If you look closely at Figure
, you’ll notice that:

  • bidirectional and monodirectional relationships have different symbols
  • the independent “Fragment 6” at the bottom really is what I had embedded in “Fragment 1” in the previous figures of this page

To make navigation easier, a slider at the top of the Piggydb window
lets you switch in any moment among a simple list of fragment names, a
synthetic Tree View, or the complete, printer-friendly layout.

Figure F

View the fragments and their interconnections.

The main problem of Piggydb

Piggydb may be the
coolest and most powerful software in the world, but until you’ve
entered a lot of content in it, it won’t be able to do much. The
good news is that Piggydb can import and export its database in a simple
XML format. Therefore, if you know just a bit of scripting, it is quite
easy to convert textual data that you already have in any other
database to XML records, all in one plain text file that Piggydb can
load. This should give you a database full of content, in which you
“only” have to add tags and/or relationships manually: boring work for
sure, but much less than (re)entering all the same stuff from
scratch. I’m playing with the idea of doing this with all my SemanticScuttle bookmarks to see what happens. If you want me to explain the details in another post, please let me know in the discussion thread below.