Permissions in Fluidinfo

Probably the hardest part of Fluidinfo to understand in detail is its permissions system. At a high level, it’s rather simple and wonderful: each user can can separately control read and write permissions for each tag (and namespace) under her username. Moreover, these are not binary controls, making them public or private, but allow the owner to allow or disallow any individual from reading, using or modifying any of her tags.

The permissions system is, in my view, one of the most powerful and important aspects of Fluidinfo, as I described in two previous posts—Permissions Worth Getting Excited About and The Permissions Sketch.

Unfortunately, understanding precisely how permissions work in Fluidinfo, and how you control them through the API, is quite hard. I think it is harder than it needs to be, largely because I think the interface to the permissions system presents the wrong abstract model of tags.

The purpose of this post is two-fold:

1. I am going to try to give the clearest explanation yet of how the current permissions actually work and how you control them through the API. (The online documentation on them is complete and accurate but rather labyrinthine.)
2. I am going to suggest a way in which it might be simplified, which will probably form the basis of new fdb commands whether the API changes or not.

I plan to add commands to fdb that provide a higher level interface to the permissions, together with a more granular interface based on the simplified scheme proposed below.

The High Level View of a Fluidinfo Permission¶

Every action that can be performed on a tag or a namespace in Fluidinfo is controlled by a permission. A permission permits or denies each user the ability to perform the associated action. The permission consists of a policy, which is either open or closed, and an exception list—a list of users for whom the policy is reversed.

By default, read actions have open policies with empty exception lists, meaning that anyone can read the data. Similarly, by default, write actions have closed policies with an exception list consisting only of the user in whose (top-level) namespace the tag exists.

So, for example, my rating tag, njr/rating has its read permissions set to:

njr/rating: read policy {open}, exceptions = []

njr/rating: write policies {closed}, exceptions = [njr]

So at the high level, this is all pretty simple. Now let’s dig a little deeper.

The Current Fluidinfo Permissions Structure in Detail¶

In reality, there is not merely a read permission and a write permission for each tag and namespace. Namespaces actually have three different write permissions, a read permission and a control permission.

Tags have even more. A tag has four separate write permissions, one read permission and two control permissions.

The control permission controls who can change the permissions on an object.

The full set of permissions is illustrated in the table below.

The first columns shows the kind of permission (read, write, control), the second the name of the action Fluidinfo uses to describe that permission, the third column shows what the permission controls in the case of namespaces, and the last column shows what the permission controls in the case of tags.

A curious thing you will notice is that in the case of tags, there are two copies of the same permission, with the same name. This doesn’t lead to mayhem, because they are accessed through different paths.

An expanded version of the table is shown below, in which I’ve added in the path (relative to http://fluiddb.fluidinfo.com) used to control the permission in question. To read the current state of the permission from Fluidinfo, you perform an HTTP GET on the relevant path, and to set a permission’s state you perform an HTTP PUT on the same URL. In these urls, I have used NSPATH to indicate the full name of the namespace (which will includes slashes, if it is a subnamespace) and TAGPATH to indicate the full path of the tag, which should include the full namespace. For example, in the case of my rating tag, TAGPATH is njr/rating. If I had a private rating tag, its TAGPATH might be njr/private/rating.

Reading and Setting Permissions¶

To read a the permissions on a tag or namespace, you perform an HTTP get on the path given in the table above. Using curl, I could achieve this by saying:

curl -u njr:'password' 'http://fluiddb.fluidinfo.com/permissions/tag-values/njr/rating?action=read'

with the appropriate password, and if I do, the output I get is:

{"policy": "open", "exceptions": []}

This is slightly painful, so I’ll illustrate it using the fdb python library from now on.

This program:

from fdb import FluidDB
db = FluidDB()
print db.call('GET', '/permissions/tag-values/njr/rating', action='read')
print db.call('GET', '/permissions/tag-values/njr/rating', action='create')

produces this output:

(200, {u'policy': u'open', u'exceptions': []})
(200, {u'policy': u'closed', u'exceptions': [u'njr']})

(The 200’s are the HTTP response code OK.)

Setting permissions is similar. The program below illustrates setting the create permission for the tag njr/geotagged, first to its default value and then adding onigiri to the access list, allowing him to tag objects with this tag.

from fdb import FluidDB, json
db = FluidDB()
print db.call('PUT', '/permissions/tag-values/njr/geotagged',
              json.dumps({'policy': 'closed', 'exceptions': ['njr']}),
              action='create')
print db.call('GET', '/permissions/tag-values/njr/geotagged', action='create')
print db.call('PUT', '/permissions/tag-values/njr/geotagged',
              json.dumps({'policy': 'closed',
                          'exceptions': ['njr', 'onigiri']}),
              action='create')
print db.call('GET', '/permissions/tag-values/njr/geotagged', action='create')

When run, the output is:

(204, '')
(200, {u'policy': u'closed', u'exceptions': [u'njr']})
(204, '')
(200, {u'policy': u'closed', u'exceptions': [u'njr', u'onigiri']})

(The HTTP response code of 204 means no content, which is what Fluidinfo returns for successful PUT operations; if the operation failed, it would produce an error code, probably a 4xx.)

Why are the Permissions Like This?¶

The permissions API is like it is because of Fluidinfo’s “mental model” (if you will forgitve the anthropomorphisation) and internal structure.

The way I like to think about Fluidinfo is that it is entirely based on tags, that may or may not have values, and which can be collected together into hierarchical namespaces. If I want to rate something a 7, I simply slap an njr/rating tag onto its object with the value 7. If I want to collect a bunch of tags pertaining to books together, I might use tags like njr/book/summary and njr/book/lent-to. The interface provided by my fdb library uses exactly this philosophy. I can attach a tag, to any object, whether or not I’ve used it before, simply by issuing a command like:

fdb tag -a 'book:animal farm (george orwell)' njr/book/lent-to='terrycojones'

Fluidinfo, however, doesn’t see it this way at all. What fdb actually has to do behind the scenes is this:

1. Check whether the namespace njr/book exists.
2. If it doesn’t, create a book (sub-)namespace under njr
3. Check whether the tag lent-to exists in the namespace njr/book
4. If it doesn’t, create the tag.
5. Finally, apply to tag njr/book/lent-to to Animal Farm’s object (the one with about tag book:animal farm (george orwell)) with a value of terrycojones.

Thus, from Fluidinfo’s perspective, tag has two completely different meanings.

• There are actual, concrete tags that have been attached to objects and which usually (but not always) have values—for example, the njr/book/lent-to tag I just attached to the book Animal Farm with value terrycojones.
• There is the abstract tag, njr/book/lent-to, which may exist even if it hasn’t actually been attached to anything.

My view is that all of this is more-or-less an implementation detail that users certainly shouldn’t have to worry about, and which ideally even developers using the API shouldn’t really have to worry about too much. But the permissions system is absolutely and resolutely grounded in this mass of implementation detail.

Personally, when forced to make the distinction between the two kinds of tags, I prefer to call the tag itself an abstract tag, and to call the individual occurrences of a tag on an object (typically with a value) simple tags. If it’s absolutely necessary to emphasize the distinction, I might call such tag instances taggings or tag instances.

The API, however, calls what I call the abstract tag, a tag, and what I call a tag a tag-value, and in particular the paths it uses to access them by these names.

Seen this way, the structure in the previous tables appears less arbitrary. This is Fluidinfo’s internal view of it:

As you see, it’s all perfectly consistent, as long as you are very careful about the distinction between the abstract tag the tagging that results when you attach a tag to an object to produce a tag instance (a tag-value pair).

Could We Improve This?¶

To Terry’s eternal delight, I’m forever coming up with suggestions for how to improve Fluidinfo. I think we could make the permissions system far easier to understand, without changing anything in the underlying architecture by renaming things to have more different names for permissions (actions, as the API calls them) in the API and by removing the need to distinguish between so-called tags and tag-value pairs. (This would go hand-in-hand with my other desire to create tags and namespaces on first use.)

This is my proposed simplication:

This has the same level of granularity as the current scheme everywhere except in the control permissions (bottom right-hand corner), where I propose controlling the pair of existing permissions with together. (I don’t see that it is important to be able to control who can change what are currently regarded as tag permissions separately from what are currently regarded as tag-value permissions; indeed, the belief that these aren’t really different is behind the proposed reorganization anyway.)

So here is what am I proposing changing:

• The read permission on a namespace is currently called list. This is reasonable, but it seems to me that it would be simpler and more conventional just to call it read. It would also mean that the same action applied to namespaces as to tags.
• Rather that having a create action on a tag-value, we would simply have a tag action on tags. So to attach a tag, you need tag permission for that tag.
• Correspondingly, rather than deleting a tag-value, we would simply have an untag action. To remove a tag from an object, you need untag permission for that tag.
• The current update permission really controls the ability to edit the metadata for a tag (currently, its description). So we would rename this metadata. (I have an ulterior motive for this: update starts with a u, as does untag, and I’d like to be able to distinguish between the main read/write-permissions using their initial letters. But I think “metadata” is easier to understand than “update” anyway.)
• Finally, as noted above, having simplified the permissions to a set of actions that can be applied either to tags or namespaces, and having removed the need for the /tag-values path, we can merge the control permissions for abstract tags and tags. (We could still maintain two internally: it’s just that there would be no mechanism for changing one without the other.)

Plans for fdb¶

I have wanted to add the ability to change permissions from the fdb command line for ages, but have always been put off by the complexity of the permissions structure and the likely complexity that would bleed into the command syntax. However, I think the simplification framework above provides a much easier model to work with. My current plan is to implement both fine and coarse controls using the mental model of the revised permissions shown above. fdb will, of course, just map actual changes to the correct underlying permissions unless and until the API changes.

More than this, however, I plan to implement a two-level approach. Normally, I think, people will want to control all the write permissions for tags and namespaces together. So I am imagining a high-level commands that move all the write permissions together, with more granular versions that allow the subcomponents to be changed. The syntax might be something like:

fdb perm r open njr/rating
fdb perm r open-except terrycojones  njr/rating

for read, and

fdb perm w closed-except njr,oniginiri,fxn njr/rating

I think the command would probably issue a warning if the base namespace owner were missed off the exception list, since that would usually be an error.

For more detailed control, you could use, for example,

fdb perm cmtu closed-except njr,oniginiri,fxn njr/rating

to change the permissions for create, metadata, tag and untag but not delete.

There is a slight issue associated with the fact that, in Fluidinfo, it is possible to have both a tag and a namespace that share the same path, and that would be ambiguous in the syntax above. But I’m not sure I care.

I’m less worried about the control permission, which will be changed more rarely, but would probably use a capital C for that.

Like Twitter For Data

Fluidinfo is

Like Twitter for Data.

How so?

Like Twitter, it lets anyone say anything about anything, but using structured data (numbers, booleans, strings etc.) instead of (just) text.

Like Twitter, it encourages short annotations — often a single bit of information like “I plan to read this” (to-read), sometimes a number, like a rating of 7/10 (rating=7), or a small bit of text, like the name of a song or the title of a book. (You can store larger things like, pictures, or books, too).

As on Twitter, different people can express different opinions about the same thing, and there’s a mechanism for grouping information on the same thing (in Twitter’s case, hashtags and trending topics; in Fluidinfo’s case, the object and its about tag). Where Twitter has search, Fluidinfo has a precise (but simple) query language.

As with Twitter, many different tools can be used to work with the same underlying data (in Twitter’s case, different client applications and the HTTP API; in Fluidinfo’s, the raw HTTP API, client libraries in a dozen languages, and various applications like Fluinfo Explorer, Tickery, Search etc.)

Finally, Twitter allows you to restrict your tweets so that only certain people can see them if you want to. Fluidinfo info gives you an entire permissions system, letting you choose exactly who can see each of your tags, and even allowing nominated others to set them for you if you like.

Fluidinfo is like Twitter for data.

fdb 2.00: New GitHub Location; Defaults to Fluidinfo-style Paths

I have made a few small but significant changes changes to the fdb.py library and command line and pushed the version to 2.00.

• I have renamed it on github as fdb rather than fdb.py. The fact that it was called fdb.py was based on my naïve (mis)understanding of github and meant that people pulling the repositroy would get it in a directory called fdb.py, which is almost unspeakably unpleasant. If you have a git remote set up to pull from it, you’ll probably have to edit your .git/config file.

  The new location is: https://github.com/njr0/fdb

• I have changed the default convention from unix-style paths (which I prefer) to Fluidinfo-style paths. The old default behaviour meant that, for example, to tag the book animal farm with with a rating of 1 and then pull back that rating and the about tag you would use a command like:

  $ fdb tag -a 'book:animal farm (george orwell)' rating=10
  $ fdb show -a 'book:animal farm (george orwell)' rating /about
  Object with about="book:animal farm (george orwell)":
    /njr/rating = 10
    /fluiddb/about = "book:animal farm (george orwell)"

  By default, you now have to use full Fluidinfo-style paths:

  $ fdb tag -a 'book:animal farm (george orwell)' njr/rating=10
  $ fdb show -a 'book:animal farm (george orwell)' njr/rating fluiddb/about
  Object with about="book:animal farm (george orwell)":
    njr/rating = 10
    fluiddb/about = "book:animal farm (george orwell)"

  If you prefer the old behaviour, simply add to your credentials file (.fluiddbCredentials in your home directory, on unix, or fluiddbCredentials.ini on Windows) a third line saying:

  unix-style-paths true

  You can also specify unix-style-paths on the command line, with the -U flag, or Fluidinfo-style paths with the -F flag.

• I’ve also fixed a minor bug in fdb, which affected some unicode queries. With the new version, you should be able to type

  $ fdb show -F -q 'fluiddb/about matches "café"' fluiddb/about
  1 object matched
  Object 10d77a6f-f9b1-4cb7-84c3-29f7454a20ce:
    fluiddb/about = "café papaya"

  and get at least one result back. Sadly, with earlier versions, you would get none.

• There’s also a new --version (or -V) flag to find out the version number of the installed copy of fdb.

Apologies for any inconvenience that the repository move and change of default convention may cause; they’re probably for the best in the medium term.

Needless to say, I have unix-style-paths set to true, but I’ll probably switch to using non-unix-style paths for future blog posts.

(Terry wins this round.)

A Search Engine for Fluidinfo

I wrote an extremely simple search front-end for Fluidinfo which you can access at http://abouttag.appspot.com/search.

It is extremely simple. You type one or more search terms into the box and it “searches” Fluidinfo about tags for those terms.

For example, here’s what happens if you type in solitude:

and here’s what happens if you type in marquez book:

Here’s what you need to know:

• All this does is turn this into a values query on Fluidinfo that ANDs together the search terms (after white-space stripping). So the query part for these two searches become

  fluiddb/about matches "solitude"

  and

  fluiddb/about matches "marquez" AND fluiddb/about matches "book"

  respectively.

• I don’t fully understand Fluidinfo’s string matching, which is based on Lucene, but it is fairly search-engine like. I think the following is true:

  • case is ignored in matching
  • punctuation is discarded
  • only whole-words match
  • accented characters match themselves (case insensitively) and not their non-accented counterparts, and vice versa. So café matches CAFÉ but not cafe and CAFE matches cafe but not CAFÉ. (This was broken when this was originally posted, but is fixed now.)

  If we’re lucky, Manuel (@ceronman) or Esteve (@esteve) might add clarification in the comments, which I will promote to here if appropriate.

• Consequences of the above include:

  • You can’t search on prefixes like film:, because the puntuation is discarded (though you can search on film and it will match things containing film:)
  • There is no stemming or substring matching, so soli won’t match solitude etc.

• At the moment a maximum of 100 results are returned and there is no paging implemented; I plan to add that soon.

• Result order is essentially random. If I implement paging, I will probably sort them. My first thought is to sort them as shortest-to-longest, with an alphabetical subsort to break ties. (Comments?)

• Various links are returned for each matching object.

  • The main link points to the raw Fluidinfo object, accessed though /about. This will show you its tags as a JSON dump.
  • The object’s ID is shown underneath, and that links to the raw object in Fluidinfo, this time through /objects.
  • Links to both the butterfly and daisy visualizations from http://abouttag.com are provided.
  • Finally, a link to the object in P A Parent’s Fluidinfo Explorer is given.

  I thought about adding a curl link too, that would show the syntax for accessing the object with curl (cURL, if you prefer), but I couldn’t really think of a neat way of doing it; a link to a one-line page seems over the top and I hate pop-ups. I suppose some kind of javascript manipulation to show the curl text below would be a possibility. Let me know if you would find this useful.

• Like the rest of the About Tag site, the application is built on Google’s App Engine. Unfortunately, this implements a time-out after 10 seconds on all HTTP requests, and even more unfortunately, some searches in Fluidinfo take more than 10 seconds. If you see a time-out, that’s probably what’s happening. This is usually because too many results are being returned. Unfortunately, Fluidinfo does not implement any form of paging or limiting of results at the moment, so the only way round this is to write a more specific query that will have fewer results.

  For example, at the moment, when I search on book, it consistently times out; if I instead search on book orwell, it consistently works.

  There’s not much I can do about this: the Fluidinfo team is working hard on making Fluidinfo faster and is (I believe) actively considering implementing some kind of paging mechanism.

• At the moment, only the about tag (fluiddb/about) is searched, (which is, I suppose, appropriate for this blog/site). It would be very easy for me to provide other interfaces. One obvious thing would be to allow the user to select the tag searched, and another would be to allow a full Fluidinfo query to be typed. If there’s interest, I can do these.

• If you want to jump straight to results, you can just add a ?q=terms to the end of the search URL (http://abouttag.appspot.com/search). For example, http://abouttag.appspot.com/search?q=george+orwell will reveal what Fluidinfo knows about the great man. Use + to separate search terms in the URL or, if you prefer, use percent encoding.

This was implemented extremely quickly, and has only been tested very briefly. Let me know if you find problems, whether you find it useful, if you’d like any of the other versions etc.

Fluidinfo: Frequently Asked Questions (FAQ)

0. Why is this FAQ incomplete It got long quickly. I decided it might be useful to publish it before I’d answered all the questions fully. Feel free to add more in the comments, or to mail, or whatever, or suggest clarifications or suggestions.

1. What is Fluidinfo?

   Fluidinfo is a social, on-line data store based on tags with values. It allows anyone to store information about anything, to query it, and to control who can see it/write to it.

   The Fluidinfo service is offered by Fluidinfo Inc., which is headquartered in New York.

2. What is FluidDB?

   Originally, the company was called Fluidinfo and the data store itself was called FluidDB. The data store itself has been renamed Fluidinfo, but the URL for the API remains as http://fluiddb.fluidinfo.com, and the system user is still called fluiddb and the about tag, fluiddb/about remains in the fluiddb namespace.

   Unix users may find it helpful to think of the fluiddb user as being a bit like root on Unix systems.

3. How do I get an account for Fluidinfo?

   You can sign up for an account at http://fluidinfo.com/accounts/new/.

4. How do I query Fluidinfo directly?

   If you know the ID for a Fluidinfo object, you can go directly to the object at the URL formed by appending the ID to the URL http://fluiddb.fluidinfo.com/objects/. For example, there is an object for the book Animal Farm at http://fluiddb.fluidinfo.com/objects/1529c459-f3f2-45e1-90f4-3ff3040ad6df.

   The result of doing an HTTP GET on that URL will be a JSON string containing a list of the public tags on that object. Some browsers will show the JSON if you put the URL into the address bar:

   {"tagPaths": ["miro/class", "fluiddb/about", "miro/books/surname",
   "miro/books/title", "njr/rating", "njr/index/about",
   "miro/books/forename", "miro/books/guardian-1000",
   "miro/books/year", "girafind/books/author", "girafind/books/title",
   "girafind/books/language", "miro/books/author"]}
   

   Alternatively, if you know the about tag for the object, you can add a percent-encoded version of it to the end of the URL http://fluiddb.fluidinfo.com/about/. For example, the about tag for Animal Farm is book:animal farm (george orwell), so you can GET http://fluiddb.fluidinfo.com/about/book%3aanimal%20farm%20%28george%20orwell%29.

5. How do I query Fluidinfo using a programming language?

   There are libraries available for many languages including python, ruby, perl, java, Go, Clojure, PHP, Lisp and Smalltalk. A list is maintained at http://fluidinfo.com/developers/documentation#libraries.

6. How do I query Fluidinfo using from the command line?

   If you have curl (cURL) on your system, you can query Fluidinfo using it. For example, to get the object with ID 1529c459-f3f2-45e1-90f4-3ff3040ad6df you can say:

   curl http://fluiddb.fluidinfo.com/objects/1529c459-f3f2-45e1-90f4-3ff3040ad6df

   or to get it by its about tag, you can say:

   curl http://fluiddb.fluidinfo.com/about/book%3aanimal%20farm%20%28george%20orwell%29

   There are also Fluidinfo-specific tools available that allow command line access to Fluidinfo. Specifically, both FOM and fdb provide different shell-like tools for reading from and writing to Fluidinfo.

7. How do I query Fluidinfo from the web?

   Probably the most powerful, general-purpose way of reading from and writing to Fluidinfo through a web browser is using the Fluidinfo Explorer

   There are a number of other online applications for doing particular kinds of Fluidinfo operations including:

   • Search: The About Tag Search page
   • Twitter user connections: Tickery
   • Visualization: The About Tag Visualizer

8. What is the about tag?

   Most objects in Fluidinfo have a special tag called fluiddb/about, generally referred to as the about tag, which is a unique unicode string. The about tag has the following special properties (guaranteed by the system user, fluiddb, which controls it):

   • About tags are unique: only one object in Fluidinfo can have any given (unicode) string as its about tag.
   • About tags are permanent: they can’t be deleted or changed after creation.
   • Objects with about tags can be uniquely specified and directly queried using their about tags instead of their IDs.

   The information sharing paradigm in Fluidinfo is for different tags to be attached to a single object to show that the data in the tags is related. The about tag is the usual way to choose an appropriate object for storing information that is “about” some particular thing.

9. What is the object ID?

   Every object in Fluidinfo has an address, or ID, which is a unique 128-bit integer. This is always formatted as a UUID (a so-called universally unique identifier), i.e. as a 32-digit hexadecimal value (using lower case for a–f) broken into blocks of 8-4-4-4-12 digits, e.g. 88888888-4444-4444-4444-cccccccccccc.

   Fluidinfo uses Version 4, UUIDs, i.e. they are randomly generated, the 13th digit (start of third block) is always a 4, and the 17th digit (start of fourth block) is always 8 or higher.

10. In what sense is Fluidinfo “a database with the heart of a wiki”?

    Key similarities between Fluidinfo and a wiki are:

    • They are both online data stores
    • Essentially anyone can add data to both
    • Both can store data about “anything”; in some sense, both also have an object/location for everything (or at least, a potential object/location for Everything).

    Key differences include:

    • Users normally write data to their own data space in Fluidinfo, rather than editing a common version of the truth: there is thus little room for edit wars in Fluidinfo.
    • Fluidinfo is primarily concerned with structured rather than unstructured data, i.e. tag values in Fluidinfo are typed and are often numeric, boolean, or more complex types like lists or images, rather than always being text.
    • The core Fluidinfo service is only accessible through its API, rather than through an (HTML) web site (though applications exist to allow ordinary web access).
    • Fluidinfo has a permissions system allowing users to control exactly who can read and write which data.
    • Fluidinfo has a query langage, whereas wikis normally only have free text search.

11. Why do I have to “create” a tag before using it?

    Because Terry says so.

    More seriously: In Fluidinfo, information is stored by attaching a tag, usually with a value, to an object. As a trivial example, I (njr) have attached my rating tag (njr/rating) to the book Animal Farm, by George Orwell, and set its value to the number 10.

    Whereas in a simpler tagging system like delicious or flickr, tags are just words, and are created on demand, Fluidinfo makes a fairly strong distinction (under the hood) between what we might call the abstract tag njr/rating and various uses of the tag to attach a particular value to an object.

    The Fluidinfo API itself requires the tag to be created before it can be used. The stated justification for this requirement is to reduce the likelihood that a user will inadvertently bring an unintended (abstract) tag into existence by making a typographical error.

    Some libraries (including fdb and FOM, mentioned above) hide this from the user and just create tags as they are used.

    It is possible that at some point in the future, the API might be modified to create tags automatically on first write.

12. What is a tag and how do I create a tag?

    The basic unit of information storage in Fluidinfo is the tag. Tags have names, which are unicode strings. The full name for a tag always includes a namespace, which might be heirerchical. For example, my username in Fluidinfo is njr and my top-level tags are things like njr/rating, njr/has-read etc. Tag names can be any combination of unicode letters and digits and may include colons, periods, hyphens and underscores (only). The total length of a tag name, including its namespace, is limited to 233 characters.

    Namespaces can be thought of a bit like folders or directories in file systems, and can be nested. For example, I could have a private rating as well a public rating, and might keep the private one in a namespace njr/private, giving a full tag path of njr/private/rating.

    In terms of the raw HTTP API, a tag called this-tag is created in namespace ns by saying:

    POST /tags/ns/this-tag
    

    In order for this to work:

    • The namespace ns must already exist
    • The user must have permission to create the tag
    • In practice, this usually means that the user must provide authentication.

    In the specific case of a user called jacqui creating a top-level tag called rating, given password pwd, the appropriate curl command would be

    curl -X POST https://jacqui:pwd@fluiddb.fluidinfo.com/tags/jacqui/rating

    (It is possible to add a description too, but that involves sending a JSON payload.)

    Note that in Fluidinfo, it is possible to have a tag and a namespace that share the same path, i.e. it is possible to have a tag called jacqui/rating and a namespace called jacqui/rating.

13. Why do I have to “create” a namespace before using it?

    As with tags, the real answer is “because Terry says so”.

    Also, as with tags, some libraries (like fdb and FOM) handle this for you.

14. What is a namespace and how do I create one?

    In general, namespaces are ways of keeping different entities with the same ‘name’ separate. One familiar example is local vs. global variables. You could also regard directories as implementing namespaces for files, in the sense that two files can have the same name as long as they live in different directories.

    In Fluidinfo, each tag lives in some namespace.

    All of a user’s tags live in that user’s namespace; for example, my tags all live in the namespace njr. Fluidinfo’s system user, fluiddb, keeps important system tags under the fluiddb user’s namespace, which is why, for example, the about tag has the path fluiddb/about.

    Namespaces may be nested, like directories, so I can have, for example, a private and a public area with namespaces njr/public and njr/private. This would allow me, if I really wanted, to have three rating tags, njr/rating, njr/public/rating and njr/private/rating.

    As with tags, namespaces must be explicitly created through the API before they can be used (though the system creates each user’s top-level namespace when it creates the user). Creating a namespace is remarkably similar to creating a user. It is achieved, by an permitted/authenticated user by POSTing to http://fluiddb.fluidinfo.com/namespaces.

    Using curl, user jacqui, with password pwd, can create a second-level private namespace by saying:

    curl -X POST https://jacqui:pwd@fluiddb.fluidinfo.com/namespaces/jacqui/private

15. What’s the difference between permissions and policies?

    Each namespace and tag has a set of permissions that govern who can read from and write to them. The default is that all data can be read by anyone, but only its owner can write data.

    Permissions are implemented as a combination of a policy, which is either open (accessible) or closed (inaccessible), and a set of exceptions—a list of users to whom the policy does not apply.

    Thus the read actions (read on tags, list on namespaces) have an open policy by default, and an empty exception list.

    The write actions (create, update and delete) have, by default, closed policies, with an exception list containing only the user in whose namespace they live.

    Permissions are stored and updated using through http://fuiddb.fluidinfo.com/permissions.

    There is also a set of default permissions for each user, consisting of a default policy and a default exception list.

    Slightly confusingly, these default permissions are stored and updated through http://fuiddb.fluidinfo.com/policies.

16. Can I use a tag without a value?

    Strictly, no; a value must always be supplied. However, the value may be NULL (JSON null). For most purposes, we think of a tag with a NULL value as being a valueless tag.

    The Fluidinfo query language includes a has primitive, which tests whether a tag is present on an object, and is useful for tags without values (i.e. tags with NULL values).

17. How can I keep information in Fluidinfo private?

    You can use the permissions system to keep any or all data (as opposed to metadata) private, and you can also hide the presence of a tag on an object using the permissions system.

    You should be aware, however, that there are various ways for anyone to see the existence of tags and namespaces, so you should regard namespace names or tag names themselves as private.

18. Do all objects have to have an about tag?

    No. When an object is first created, whoever requests it can either specify an about tag or not. If none is specified, the object will not have an about tag, and will be forever without one.

19. How do I know what conventions to use for about tags?

    The About Tag blog is largely concerned with that very question.

    There are no rules: you can use whatever conventions you like.

    The posts in this blog tagged conventions have lots of suggestions, the About Tag web application has several online resources for constructing about tags, and the abouttag.py library has python code for producing normalized, canonical suggested about tags for various kinds of entities.

20. Can I have a username that is a URL?

    The owner of a domain can normally have that domain as a username in Fluidinfo. In that way, users can gain a level of confidence about the provenance of information under such URL namespaces.

    If you do not own the domain in question, you will not normally be permitted to register a domain-like username.

21. How do I tag an object in Fluidinfo?

    This is achieved using a PUT on either the relevant /about or /objects path for the object. It is slightly tricky using the raw HTTP API as you have to send a JSON payload. See http://fluidinfo.com/cookbook/#putvalue.

    With fdb, you just say:

    fdb tag -a "book:animal farm (george orwell)" njr/rating=10

    or, if you know, prefer to user the object ID,

    fdb tag -i 1529c459-f3f2-45e1-90f4-3ff3040ad6df njr/rating=10

    if you have it configured to require full tag paths, and it will even create the tag for you if it doesn’t exist.

22. How do I get the value of a tag from Fluidinfo?

    To get the rating njr/rating from the book Animal Farm you just do an HTTP GET on the relevant /about or /objects path, adding njr/rating to the end. So either:

    GET https://fluiddb.fluidinfo.com/objects/1529c459-f3f2-45e1-90f4-3ff3040ad6df/njr/rating

    or, for the about version,

    GET https://fluiddb.fluidinfo.com/about/http://fluiddb.fluidinfo.com/about/book%3aanimal%20farm%20%28george%20orwell%29/njr/rating

    Using curl, this becomes:

    curl https://fluiddb.fluidinfo.com/objects/1529c459-f3f2-45e1-90f4-3ff3040ad6df/njr/rating

    or alternatively:

    curl https://fluiddb.fluidinfo.com/about/http://fluiddb.fluidinfo.com/about/book%3aanimal%20farm%20%28george%20orwell%29/njr/rating

    Using fdb, configured to require full paths, you do

    fdb show -i 1529c459-f3f2-45e1-90f4-3ff3040ad6df njr/rating

    or, more simply

    fdb show -a 'book:animal farm (george orwell)' njr/rating

23. How do I search Fluidinfo?

    Fluidinfo provides a query language that allows rather precise querying of information in Fluidinfo.

    For something more akin to a web search on about tags, try try http://abouttag.appspot.com/search.

24. How does string matching work in Fluidinfo?

    The matches operator in Fluidinfo’s query language is based on Lucene’s text matching.

    Matches are whole-word, case insensitive and ignore punctuation.

25. Why don’t numeric comparisons work in Fluidinfo?

    Fluidinfo currently regards floating point values and integers as entirely separate domains and comparisons between the two fail. This is bug.

    Thus, at moment, if njr/rating is 5 on an object and njr/rat.ing is 5.0 the folling matches will FAIL:

    njr/rating = njr/rat.ing    CURRENTLY FALSE
    njr/rating < 6.0            CURRENTLY FALSE
    njr/rat.ing < 6             CURRENTLY FALSE
    njr/rating = 5              CURRENTLY FALSE
    njr/rating = 5.0            CURRENTLY FALSE
    njr/rat.ing > 1             CURRENTLY FALSE
    njr/rating > 1.0            CURRENTLY FALSE

    (Booleans are also not available for any kind of numeric matching; in fact, booleans aren’t available for any kind of mathing at all at the moment, which is also a bug.)

26. How do I limit the number of results from a Fluidinfo query?

    This is not currently possible.

27. How do I perform a more powerful string match in Fluidinfo?

    Only basic Lucene string matching is currently available using the matches operator, though obviously this can be combined with other query terms.

    A number of enhancements are under consideration.

28. How do I know an about tag won’t change in Fluidinfo?

    The system guarantees that about tags will never change.

29. What if several objects in Fluidinfo have the same about tag?

    The system guarantees that about tags are unique and immutable.

30. How do I store more complex information in Fluidinfo?

    So-called primitive types are first-class citizens in Fluidinfo. These are things like nulls, booleans, integers, floats, unicode strings and set of strings. They may be used as the basis for queries with comparison operators, and are exchanged using the Content-Type application/vnd.fluiddb.value+json

    Fluidinfo can store data of any type as an “opaque” value, meaning that it can be stored and retrieved, but Fluidinfo doesn’t ever look inside the content. To do this, simply specify the content type as any MIME type except application/vnd.fluiddb.value+json.

    If you want to represent more complex data structures in Fluidinfo using primitive types, it’s just a question of deciding conventions. For example, some suggestions on storing structured tabular data and forming links between objects are given in this blog post.

31. Where can I get the API documentation or Fluidinfo?

    The most detailed information is available at http://api.fluidinfo.com/html/api.html.

    Higher level documentation is available at http://doc.fluidinfo.com/fluidDB/api/http.html.

    Even higher level documentation is available at http://doc.fluidinfo.com/fluidDB/.

32. Who is behind Fluidinfo?

    Fluidinfo is a New York company founded by Terry Jones.

    It has funding from both institutions and individuals. Some details are available at http://fluidinfo.com/investors/.

    Information on the team is available at http://fluidinfo.com/team/.

33. Where can I get help on Fluidinfo if I get stuck?

    There are usually friendly and helpful people available on the #fluidinfo IRC Channel at Freenode.

    There are Google Groups at fluidinfo-users and fluidinfo-discuss.

    Everyone involved in Fluidinfo seems to be on Twitter, and most are pretty responsive. See a list of users at http://fluidinfo.com/developers/documentation#community.

34. What is the Fluidinfo Explorer?

    The Fluidinfo Explorer is a web-based interface to Fluidinfo that has some similarities to Windows Explorer or the Mac Finder.

    It is the brainchild of P A Parent (paparent).

    It is the most comprehensive online interface to Fluidinfo currently available, and allows both browsing and (if you log in) writing of data to Fluidinfo (for registered users).

35. Can I see a visual representation of a Fluidinfo object?

    Of course. Try http://abouttag.appspot.com.

36. How do I change the permissions on a tag?

    This is described in the cookbook.

37. How do I change the permissions on a namespace?

    See the cookbook.

38. What is /values?

    /values provides an access mechanism for getting or setting the values for all objects that match a given query. It can be dramatically more efficient than getting or setting values one at a time.

    It is described at http://blog.abouttag.com/2011/04/fdbpy-130-embryonic-values-api-support.html.

39. What is /about?

    /about is the end of a base path for accessing objects directly using their about tags. For example, you can find the tags on the object with the about tag paris by using

    GET http://fluiddb.fluidinfo.com/about/paris

40. What is /objects?

    All objects can be accessed through the /objects path if you know their addresses. For example, you can find the tags on th object with the about tag paris by using

    GET http://fluiddb.fluidinfo.com/objects/881d95b2-e9f0-40c8-a11e-964f349e01b1

    gets the tags on the object with about tag paris, whose ID is used in the URL.

41. Why is Fluidinfo so slow? And will it get faster?

    It’s a very early version of a rather flexible system. Improved performance is the top priority for the development team; expect improvements.

42. Can I use wildcards in Fluidinfo?

    Not yet.

43. How do I match a boolean value in Fluidinfo?

    You can’t, at the moment. This is a bug.

44. Are there any useful videos on Fluidinfo?

    Yes! There are lots. There’s a YouTube channel at http://www.youtube.com/fluiddb and Google video search finds even more.

45. Are there are any useful slide shows on Fluidinfo?

    Yes! http://www.slideshare.net/fluidinfo.

46. Are there any blogs on Fluidinfo?

    Yes!

    • The Fluidinfo Blog: http://blogs.fluidinfo.com/fluidinfo/
    • Terry (CEO)’s blog: http://blogs.fluidinfo.com/terry/
    • Nicholas “third guy” Tollervey’s blog: http://ntoll.org/
    • Mine (About Tag): http://abouttag.blogspot.com/

47. Is there an IRC channel for Fluidinfo?

    Yes. #fluidinfo IRC Channel at Freenode.

48. Why is it called Fluidinfo?

    Terry hates computers and think they make working with information too rigid and unnatural for humans. Fluidinfo aims to make it easier for people to annotate the world with comments, snippets of information and so forth, in a much more flexible, human, fluid manner.

49. What is the sandbox?

    The sandbox is a secondary instance of Fluidinfo that can be used for testing, both by the community and the company. Unlike the main instance, you should expect that the sandbox will sometimes have its data removed, and it will usually get an updated version of the API before the main instance is upgraded.

    To user the sandbox, replace http://fluiddb.fluidinfo.com with http://sandbox.fluidinfo.com in all URLs.

    Not all main instance users currently have sandbox access, but if you haven’t and would like it, get in touch with the team and they’ll make it happen.

50. How do I find out whether Fluidinfo is up (the server status)?

    The team tries to post a message on the front page at http://fluidinfo.com has a message when we know the server is down. In practice, a message usually appears on Twitter (@fluidinfo) even sooner.

51. Is there a test user for Fluidinfo?

    Yes. The test user is called test. Its password is the same as its username. It exists on both the main instance and in the sandbox.

52. How do I destroy a Fluidinfo Object?

    You can’t. Fluidinfo objects are shared and eternal.

53. How do I make a Fluidinfo Object private?

    You can’t. All Fluidinfo objects are shared. However, if you create a new object without an about tag, it will be accessible only to those who know or can guess its ID (which is a 128-bit integer) and to those who can find it by query. If you use only private tags on the object, it is unlikely anyone else will find/use it.

54. How do I hide a tag completely?

    You can’t. You can use the permissions system to stop other people seeing which objects a tag has been used on, and to stop them seeing any of its values data, but the existence of the tag is visible to any Fluidinfo user who knows where to look.

55. What is Fluidinfo’s query language?

    Fluidinfo’s query language is pretty simple and is documented at http://doc.fluidinfo.com/fluidDB/queries.html.

    Examples include:

    has jacqui/rating               (returns objects tagged with any jacqui/rating)
    
    jacqui/rating > 7
    jacqui/rating >= 7
    jacqui/rating = 7
    jacqui/rating <= 7
    jacqui/rating < 7
    
    fluiddb/about contains "film"   (whole-word, case-insensitive string match)
    
    jacqui/rating > 7 except has njr/has-read  (return objects with a jacqui rating over 7
                                                only if they don't have an njr/has-read tag)
    
    jacqui/rating > 7 AND thelonious/rating > 7
    jacqui/rating > 7 OR has thelonious/has-read

    Notes:

    • Numeric comparisons between floating point and integer values all fail at the moment. (This is a bug.)
    • Booleans cannot be treated as numeric values. (This is apparently a feature.)
    • No comparison operators are currently available at all for boolean values (though has can be used). (The lack of comparison operators is a bug.)
    • The match operator ignores case and discards punctuation and is “whole-word” oriented. There is no way to override this behaviour at the moment.
    • There is no not operator and no not equal operator. This is largely to make accidental writing of queries that return most of the objects in the system harder. The except operator can often be used to achieve ends that might more naturally be achieved using not or is not equal to.

56. How do I report a bug in Fluidinfo?

    In practice, jumping onto the #fluidinfo channel on IRC and discussing it with one of the developers in there will often be the best way. Or discuss it in one of the Google Groups (fluidinfo-users or fluidinfo-discuss)

    If you’d rather send a mail, for the moment, just send it to info@fluidinfo.com for the moment.

57. Are there any Google groups associated with Fluidinfo?

    There are Google Groups at fluidinfo-users and fluidinfo-discuss.

58. Is Fluidinfo open source or free software?

    Not currently. This may change.

    (Free in this context refers to Richard Stallman’s notion of free software—free as in “free speech”, rather than free as in “free beer”. Fluidinfo does not charge for use of the Fluidinfo service at present.)

59. Is Fluidinfo Inc. a non-profit company?

    Fluidinfo is a “for-profit” company; but it has not yet made a profit.

60. What are the terms of service for Fluidinfo?

    These are available at http://fluidinfo.com/terms/.

61. What is the “payload” that the Fluidinfo documentation talks about?

    Everyone knows that when you do an HTTP GET, you get a lump of data back. In the case of an ordinary web page, this consists of a few headers followed by the HTML for the page.

    It’s less widely known that other HTTP actions, like PUT and POST can include data in the same way.

    This data is known as the payload.

    In the case of Fluidinfo, the payload is most commonly serialized JSON data with the Content-Type set to application/vnd.fluiddb.value+json.

    More complex data can have other MIME types.

    Most Fluidinfo operations that involve writing data to the system require the data to be sent as the payload.

62. What is JSON and how do I use it?

    JSON is the JavaScript Object Notation.

    It provides a simple way to serialize various basic (“primitive”) types, such as nulls, booleans, integers, floats and unicode strings, lists, and associative arrays (hashes/dictionaries) as strings and is widely used on the web as a way of exchanging structured data. (Ironically, most so-called AJAX sites now use JSON to exchange data, rather than XML, suggesting that it might be more accurately known as AJAJ.)

    Primitive types are passed to and from Fluidinfo using serialized JSON with the Content-Type set to application/vnd.fluiddb.value+json.

    Other MIME types may also be used, but are opaque to Fluidinfo.

63. What is the results format for /values queries?

    Here’s an example, in which I’ve formatted the output to try to emphasize the structure:

    curl http://fluiddb.fluidinfo.com/values?query=fluiddb/about%20matches%20%22dadgad%22&tag=fluiddb/about
    
    {
      "results": {
        "id": {
          "296ad46c-ec88-42ae-ae05-3a9d00ab3718": {"fluiddb/about": {"value": "'DADGAD'"}},
          "1fb8e9cb-70b9-4bd0-a7e7-880247384abd": {"fluiddb/about": {"value": "DADGAD"}},
          "4d98a0de-b19e-4ae4-bb31-967d7a2920d7": {"fluiddb/about": {"value": "dadgad"}}
        }
      }
    }

    As you can see, it’s a JSON hash with the single key results. That item is another hash containing the key id (which later might be able to be about). This item in turn is another hash with keys that are the IDs of the matching items. The values of those items are a hash with the requested tags as keys and their values as a hash keyed on value. It’s slightly verbose, but flexible.

64. Is Fluidinfo on Twitter?

    Oh yes.

    There is an official Fluidinfo user (@fluidinfo), the entire development team is on twitter (see http://fluidinfo.com/developers/documentation#community) and most if not all the investors are there too.

    There’s also a Fluidinfo-based application, Tickery that lets you explore the Twitter social graph with the help of Fluidinfo.

65. Does Fluidinfo use Unicode?

    Yes. All string data in Fluidinfo is unicode.

66. How do I use accents and non-European characters with Fluidinfo?

    All string data in Fluidinfo is unicode. You would normally encode as UTF-8 during interchange.

67. What’s all this stuff about MIME types in Fluidinfo?

    Most values stored in Fluidinfo have simple types, the main examples being nulls, booleans, integers, floating point values and unicode strings. Fluidinfo also supports a type that is a set of unicode strings. These are known as primitive values.

    Primitive values in Fluidinfo have the Content-Type application/vnd.fluiddb.value+json, indicating that they are serialized JSON representations of these primitive types.

    When you get any primitive value from Fluidinfo, the content type will be set to this.

    Similarly, when you send a primitive value to Fluidinfo, you should set the content type to application/vnd.fluiddb.value+json.

    Fluidinfo will happily store store values of any other MIME type. in these cases, you set the content type to the appropriate MIME values when writing, and the system will return the same content type when you retrieve such values.

    It would be nice not to care, and if you use an application or client library, it may hide this for you; but if you use the native HTTP API, you may need this information.

68. What does it cost to use Fluidinfo?

    Use of Fluidinfo is currently free of charge. If this makes you very unhappy, get in touch and we’ll try to come to a more acceptable arrangement for you.

69. Is there an object for each user in Fluidinfo?

    Yes. The object for a user with username thelonious has the about tag Object for the user named thelonious. (Use https://abouttag.appspot.com/fluiddbobject to find these; it will also show you which objects Fluidinfo uses to store information about tags and namesapces, each of which has a corresponding object.)

70. Are there any cool apps I should know about for Fluidinfo?

    Yes!

    • http://tickery.net
    • http://abouttag.appspot.com
    • http://http://explorer.fluidinfo.com/fluidinfo

    and many more besides.

71. Are there any mobile apps for Fluidinfo (iPhone/Android)?

    Not yet, as far as I know, though some sites like http://abouttag.appspot.com work pretty well on mobiles.

72. Is there an easy way to import data into Fluidinfo in bulk?

    Try flimp (described at http://blogs.fluidinfo.com/fluidinfo/2010/11/19/importing-data-into-fluiddb-with-flimp/).

73. What is tickery?

    Tickery is a Fluidinfo web application that lets you explore the social graph from Twitter.

74. Why is there so much data on Twitter users in Fluidinfo?

    Tickery stores its data in Fluidinfo.

75. Is the id for an object a tag in Fluidinfo?

    No.

76. What is a UUID?

    Every object in Fluidinfo has an address, or ID, which is a unique 128-bit integer. This is always formatted as a UUID (a so-called universally unique identifier), i.e. as a 32-digit hexadecimal value (using lower case for a–f) broken into blocks of 8-4-4-4-12 digits, e.g. 88888888-4444-4444-4444-cccccccccccc.

    Fluidinfo uses Version 4, UUIDs, i.e. they are randomly generated, the 13th digit (start of third block) is always a 4, and the 17th digit (start of fourth block) is always 8 or higher.

77. Who or what is the fluiddb user?

    Fluidinfo stores its data in Fluidinfo under the namespace of a system user called fluiddb. For example, the about tag is actually fluiddb/about.

    The reason for the name fluiddb is historical; originally, the company was Fluidinfo and the data store was FluidDB. Changing it now would be painful.

78. How do I authenticate to Fluidinfo using curl (cURL)?

    An example is

    curl -X POST https://jacqui:pwd@fluiddb.fluidinfo.com/tags/jacqui/rating

    where jacqui is the username and pwd is the password.

79. Is it tags or values that are typed in Fluidinfo?

    Values.

    The same tag can have different types of values when applied to different objects.

80. Can I set permissions for a particular tag on a particular object?

    No. Permissions operate at the level of tags (and namespaces), not “tag instances” (the tagging of a particular object with a value using a given (abstract) tag).

81. Who is Terry (@terrycojones)?

    The Terry Jones mentioned in this FAQ and blog is the founder of Fluidinfo Inc., and the conceiver of the Fluidinfo system.

    He is @terrycojones, he blogs in various places, but mostly at http://blogs.fluidinfo.com/fluidinfo/ and his home page is http://jon.es/terry.html.

    He has no connection to Monty Python’s Flying Circus and does not threaten to burn holy texts.

82. What is application/vnd.fluiddb.value+json and should I care?

    Most values stored in Fluidinfo have simple types, the main examples being nulls, booleans, integers, floating point values and unicode strings. Fluidinfo also supports a type that is a set of unicode strings. These are known as primitive values.

    Primitive values in Fluidinfo have the Content-Type application/vnd.fluiddb.value+json, indicating that they are serialized JSON representations of these primitive types.

    When you get any primitive value from Fluidinfo, the content type will be set to this.

    Similarly, when you send a primitive value to Fluidinfo, you should set the content type to application/vnd.fluiddb.value+json.

    Fluidinfo will happily store store values of any other MIME type. in these cases, you set the content type to the appropriate MIME values when writing, and the system will return the same content type when you retrieve such values.

    It would be nice not to care, and if you use an application or client library, it may hide this for you; but if you use the native HTTP API, you may need this information.

83. I’ve lost my password for Fluidinfo. How do I recover/reset it?

    Go to https://fluidinfo.com/accounts/password_reset/

84. Is there a tutorial introduction to Fluidinfo?

    Try the cookbook.

85. Are there any books available on Fluidinfo?

    Not yet. But watch this space.

86. Can a company get its own private instance of Fluidinfo?

    It’s not out of the question. Get in touch with Terry (@terrycojones) to discuss that.

87. Can I invest in Fluidinfo?

    It’s not out of the question. Contact Terry (@terrycojones) Jones or Russell (@rustlem) Manley to discuss that.

88. Fluidinfo is supercool: how can I help?

    Get an account and do something cool with it.

    Write a killer Fluidinfo application.

    Join us.

    Put up some interesting data (we can help).

    Write a blog, tell your friends, tweet about it.

    Get in touch and give us feedback.

89. I’m not very technical but like the look of Fluidinfo: is there a way for me to use it?

    That should get easier over time. For now, try the applications like Tickery, Search, the Explorer, the Chrome extension for the O’Reilly API etc.

90. Where can I find the API for O’Reilly books?

    Read http://blogs.fluidinfo.com/fluidinfo/2011/03/21/the-structure-of-oreilly-book-and-author-data-in-fluidinfo/.

91. Where can I find the boingboing API?

    Read http://blogs.fluidinfo.com/fluidinfo/2011/01/27/how-we-made-an-api-for-boingboing-in-an-evening/.

92. Where can I find the read/write-web API?

    Read http://blogs.fluidinfo.com/fluidinfo/2011/02/23/readwriteweb-readwriteapi/

93. I’ve heard Fluidinfo is like a universal API. What does that mean?

    This post explains what it means. http://blogs.fluidinfo.com/fluidinfo/2011/02/23/how-to-make-an-api-in-fluidinfo/

Fluidinfo: The Vision

Let’s create an online storage system in which there is a place for information about everything—everything that exists, everything that could exist, and everything that can be imagined.

Let’s make it so that anyone can store any information they like, about anything they like, in any digital form they like.

Let’s make it easy to find information in this system, and to extract it, by baking in a query language that’s so simple that even real people might use it.

Rather than trying to force people to visit a particular website, or use particular tools or languages to interact with the system, let’s make the system a first-class internet citizen by exposing all its functionality through HTTP (and only through HTTP). Rather than dictating how it be used, let’s let anyone access it through any HTTP-enabled technology.

Finally, let’s make the system social, in the sense of making it easy for people to share information, either with everyone, or just with particular nominated individuals, but let’s make the permissions system rich enough to make it equally easy to keep information private; and let’s extend this permissions to govern the writing of data as well as reading.

Fluidinfo is a realisation of this visionary system. It exists. You can use it, today.