Peter Robinett

anyMeta Concepts

anyMeta is built upon a few simple but fundamental concepts. Master them and you'll be able to do just about anything you can imagine with anyMeta!
Often when people build a system they make a model of what they need at that moment and then build their system upon that model. Later, when their needs change or expand they have to go back and change their fundamental model, and thus the core foundations of the system. AnyMeta doesn't work like that: it was designed with the realization that models will change over the lives of systems, that Mediamatic is building many such systems, and that generic foundations can be developed. The only way to make these foundations universal is to skip any data modeling at the core technology level. In return for sacrificing a small amount of specificity we gain incredible flexibility and the ability to store just about anything. The strength of anyMeta is that it really emphasizes structured data storage and a future-proof flexible system. Once you've learned the API of one of these systems then you can use the APIs of all the others, since they all have the same basic structure and operate upon the same fundamental principles. anyMeta combines a quite usable social network environment and at the same time it's a highly structured Semantic Web-based information management system. Things Kinds Types Properties Edges Predicates Multilingualism Open-CI Authoritative and Non-Authoritative Things Permissions Modules Conclusion Things In seeking to make anyMeta universal we have to look at the world around us and get somewhat philosophical. We start with a simple assertion: any basic object is at root a Thing. For programmers, this is like how everything is an object is an object-oriented system. From the basic unit of a Thing we then attach metadata to them to describe the Thing, giving us the name anyMeta: everything is meta information! This metadata takes several forms, both as categorizations and as properties that independently describe the Thing, and as relationships with other Things. Kinds Kinds are mutually exclusive categorizations of Things and thus each Thing can only have one Kind: you're either a Keyword or a Person, you can't be both. But, as anyMeta is built upon generic foundations, the system allows me to change a Person into a Keyword with the click of a mouse. Because Kinds are mutually exclusive, it makes it a lot easier to reason about certain Things. Because Kinds are so basic they are often reused between anyMeta systems and most anyMeta systems use all the standard Kinds. That being said, you can naturally create more Kinds. Oh, and of course all Kinds are Things. The standard Kinds are: ARTEFACT ARTICLE ATTACHMENT INSTITUTION KEYWORD LANGUAGE LISTPUBLISH LOCATION NOTE PERSON ROLE SET TAG THEME TOPIC TYPE Types A Type is a simple categorization of a Thing, and a Thing can have as many Types as you like. Go wild with your Types, but don't try to make Types for things that are really relationships. Consider a Person: can he be a Father or a Son or an Author? These things are not Types because they do not exist independently: he is a Son in relation to the Person who is his Father. While a Thing may have several Types, Types generally only apply to Things with a Kind that is logical for the Type. In this way, we can consider a Type a sort of elaboration of a Kind. Below is a list of common Types organized by their associated Kind: ARTICLE REPORT HELP TEXT NEWS STORY ABOUTUS ARTEFACT IKCAM TICKET BOOK EVENT SIGN_UP_REQUIRED PUBLICATION PROJECT WEBSITE INSTITUTION PUBLISHER LISTPUBLISH MAILINGLIST BLOG LOCATION COUNTRY PERSON NOCONTACT SET MAILING GALLERY FORUM COMPETITION NAVIGATION Properties Properties are a generic way to add more stuff to Things in a structured way. Every Thing has some basic information like you might expect a news article to have: title, body, start and end dates, etc. Some things will only have a start date, not an end date: e.g. a photo. But even a photo might have both based upon the shutter time. Every Thing has standard GPS coordinates and publishing states (visibility and editing settings). If I know what kind of Thing a Thing is, I can add specific stuff. For instance, users have passwords. A user account is a Thing that is Kind Person. However, right now any Thing can be a User. In general it could be any Thing though right now it is almost always a Person Thing. Organizations are also Things and could also be a User if desired. It is convention that only Persons are Users and that you can only send a message or become friends with a Person. Several types of properties of Things are Things themselves: Type, Kind, Role. Some of these things are really part of the architecture of the system but we treat them as content so we can have a flexible system. Tags and Keywords are more 'free', and more part of the content or editorial architecture. Edges Practically anything can be any Thing and Things have very little inherent data. Thus, the meaning of a thing is primarily determined by its relationships, not its atoms or bits. That's primarily how you give structure to your data, by creating meaningful links between Things. These links in anyMeta are called Edges, and every Thing can be linked via an Edge. For instance, we can say that I (that is, the Peter Robinett Thing) current am in Amsterdam. However, I can also make Edges to indicate when I lived in Place Things like London, Paris, and Brussels. Edges can contain start and end dates for this reason. For some conventions, date of birth and date of death for example, they are stored in non semantic ways to allow for circumstances where not all information is known, for instance not knowing where I was born. Oh, and an Edge is not a Thing. This is a very important point to remember, as this means that when working with anyMeta you will work with two basic concepts, Things and Edges. Predicates While an Edge is a link between two Things, it's not very useful unless we say what type of link we've made. A Predicate is a property of an Edge which categorizes it, just like a Type categorizes a Thing. For this reason Predicates are very important, though I can make Edges without Predicates: it's not useful but it's possible, just like you can have a Thing without a Kind or a Type. While Edges are not Things, Predicates are, just like Types and Kinds are also Things. We can say that Edge::Predicate as Thing::Type. You can create multiple Edges with the same Predicate between the same two Things. To distinguish between them, then, the additional data directly on the Edge, like the start and end dates, becomes very important. For example, I might use the same KNOWS_OF Predicate to indicate my changing relationship with another person over time: they were friend from time X to Y, enemy from X1 to Y1, and finally friend again from X2 to Y2. Of course you would probably use different predicates to represent that changing relationship, but you get the idea. While Predicates describe a relationship between two Things in one direction, you can look at Edges from both the perspective of the subject and the object. This might seem confusing, so let's take a specific example. Let's say Peter knows John. Thus, there is a an Edge with Predicate KNOWS_OF with subject Thing Peter and object Thing John. It is easy, then, to ask who Peter knows, but anyMeta also lets you ask who knows John using a query with the same Predicate while indicating the John Thing is the object of the Edge, not the subject. This being said, because Predicates are usually named taking into consideration one direction of the relationship, sometimes there are related Predicates for Edges in either direction. For example, PARTICIPANT and PARTICIPANT_OF. The Predicate creator can decide between which Kinds of Things a Predicate is valid. This, of course, is not a structural limitation but a way to add more information through constraints, showing that Predicates function as a sort of content. Like with Kinds there are some Predicates that are common to all anyMeta systems and include ones like ACTOR, AUTHOR, LOCATED_IN, and TAKEN_AT. Every project will invariably create new Predicates, but Mediamatic constantly tries to weed them out, looking for similarities between projects and removing near duplicates so as to prevent a loss of common points of comparison across anyMeta systems. For example, 'I like it', 'I'm interested', and 'This is my favorite' on different anyMeta systems are all represented by the INTERESTED Predicate. Likewise the Predicate configuration (between which Kinds a Predicate is valid) varies per website. Here is a list of common Predicates: ABOUT ACCESS_GRANTED_BY ACCESS_GRANTED_TO ACTOR ATTENDED_BY AUTHOR BLOCKS BLOGPOSTING CHILD CLAIMED_BY COMMENT CONFIRMED_PARTICIPANT DOCUMENT EXTRA_CONTEXT FIGURE FRIEND HAS_TYPE ICON INTEREST KIN KNOWS KNOWS_OF LIVED LOCATED_IN LOOKS_AFTER MEMBER MODERATOR NARRATOR ORGANISED_BY PAID_PARTICIPANT PARTICIPANT PARTICIPANT_OF PRESENTED_AT PUBLISHED_BY REGISTERS RELATED RESOURCE SETMEMBER SETMOTHER SIBLING SPOUSE SUB_PROPERTY_OF SUBSCRIBER TAKEN_AT WORKS_FOR Multilingualism AnyMeta used a multilingual label file which is a very big translation table. All text for Things can be given in multiple languages, as can text for things like Predicates. This separation between an object and its text also allows standardization across anyMeta sites like the INTERESTED Predicates we mentioned previously while still giving site owners and editors the freedom to use the most appropriate text for their users. This is all handled behind the scenes and only becomes apparent to a user when they are an author creating versions of their text in multiple languages or are an API user requesting everything about a Thing and getting back versions of its text in all given languages as part of the response. Open-CI Open-CI is an initiative spear-headed by Mediamatic to make it easier for social sites to safely and securely share data while respecting privacy and only doing so when you ask them to. Naturally all anyMeta sites support Open-CI. With Open-CI you can log in on one anyMeta site with your account from another anyMeta site and link a photo on the site to an event on a third site, all securely. You can learn more at Resource URIs As an API user the key take-away from Open-CI is that API requests can return results from remote sites in the Open-CI network. Every result in the set, regardless of origin, will have a resource_uri, which is a fully-qualified URL of the item on its home site. anyMeta resource_uris are in the form While these id URLs aren't part of the main anyMeta API, they can be used to get a variety of useful data and are detailed later in this document in the section called //thing_id. The URL can be used as identifiers in API requests and can be parsed to find the home system of the result. Every resource_uri is unique to an anyMeta server. When an entry is on the same anyMeta server as the one queried it will also contain a unique integer thing_id or event_id, so you will probably choose not to use resource_uris in your everyday API queries. Authoritative and Non-Authoritative Things Thing records can be copied from one anyMeta server to another. The original Thing will be marked as, and already was, authoritative. The new Thing on the second server will be marked as non-authoritative and will use the remote Thing's resource_uri as its own in order to link back to the original. The second anyMeta server will refuse to ever make any direct modifications on the new Thing and will instead mirror all changes to the remote authoritative Thing on the local non-authoritative one. It is not possible to have both the authoritative and non-authoritative Things be on the same anyMeta system, as their resource_uris would conflict. Permissions anyMeta has a permissions system that restricts certain actions in the system to certain users or groups of users. The first, or 'sysadmin', user has all permissions. By default a normal user has sufficient permissions to create new Things and to create Edges between Things they own: that is, to add content to the system. Permissions that standard users do not have include creating new types and edges and creating new users. A good rule of thumb is that normal users can create content while editors and other site managers and owners can create content and the context used in making the content. If you as an API user need more advanced permissions like the ability to create anyMeta users you will have to directly contact the site owner to request them. They can then grant authorization to use specific permissions via the anyMeta admin section. Related to permissions is the concept of publishing state. Even if a person would be able to see a Thing, for example if it is visible to everyone, they will not be able to see it if it is not marked as published. Many API methods default sensibly to the unpublished state and have to be explicitly marked as published, so this is an important potential gotcha. Modules AnyMeta has the concept of modules that can add additional features to a standard anyMeta install. Any API methods they provide tend to live under a namespace. The methods provided by the standard anyMeta system follow this convention and use the anymeta.api.method pattern. While most modules don't have much impact on the API, you should look out of the ThingDump module, as the ability to get a dump of everything about a Thing is very useful. This module is provided but not enabled by default, so contact your site administrator if you'd like to use it. Generally, though, you should be fine with the many API methods provided by the base system. Conclusion The challenge of anyMeta is to stimulate people to be extremely structured when inputting data into the system while still enjoying entering their data. All about creating links between structures to create structured meaning. Any anyMeta system uses all the Kinds because they're so basic. You need to look at what Types and Roles are used to understand the basic information architecture of the specific anyMeta system. All the rest is just content. Before you start an anyMeta site you start looking at your ontology/domain model/resource description framework, and every anyMeta project has an RDF (not completely stored in a machine readable format at the moment). Mediamatic makes sure to map what Kind and Types the project has and what types of Predicates exist. A blackboard exercise is the normal start of a Mediamatic project and focuses on exceptions, as this will reveal places where any new Types, Kinds, or Predicates are required. People familiar with the concepts of the Semantic Web will notice many similarities with anyMeta, as both are concerned with meaningful links between things. However, much of anyMeta predates and/or happened simultaneously with the Semantic Web, which is why there are some language differences. For example, a Role in anyMeta means the same thing as a Predicate in the jargon of the Semantic Web. Like with the Semantic Web anyMeta enables you to do advanced queries based around actual meaning across several levels of information, such as looking for anything involving a certain person at a certain location that has a certain tag.