"This is a problem caused by an update in the CSS used to layout the page, and some faulty mark-up..."
A Metaweb database is a sea of knowledge organized as a graph: a set of nodes and a set of links or relationships between those nodes. This chapter covers the key features of the Metaweb architecture, and explains how Metaweb types and properties tame this vast graph of knowledge by defining a manageable object-oriented view of it.
Figure 2.1 illustrates one tiny (hypothetical) piece of the Metaweb graph of nodes and relationships.
This portion of the Metaweb graph organizes knowledge about something named "Arnold". It tells us that Arnold is a Person, Politician, Body Builder, and Actor. It tells us that Arnold's country of birth is Austria, his political party is Republican, and that he acted in something named "Terminator" (which is an instance of something known as a "Film"). The relationships in the graph are bi-directional, so this figure also tells us, for example, that Austria has Arnold as a citizen, the Republican Party has Arnold as a member, and that Terminator has Arnold as a cast member. (Note that this is an example only. An "Arnold Schwarzenegger" node does exist at www.freebase.com, but it may nor may not have the particular relationships pictured here.
This nodes-and-relationships representation of knowledge is ideal for searching algorithms, but is not ideal for human understanding: we quickly become lost in the maze of links. In order to make the data structure more understandable to humans, Metaweb allows us to view the graph through an object-oriented lens. Rather than thinking about nodes and their relationships to other nodes, this object-oriented view lets us think about objects and their properties:
Arnold
sex: male
birthdate: 1947-July-30
country of birth: Austria
political party: Republican
film: Conan the Barbarian
film: Terminator
film: Kindergarten Cop
elected office: Governor of California
In this view, Arnold is an object with a set of properties. Each property has a name and a value. What is missing from the view is any kind of typing. In many object-oriented systems, each property of an object has a known type, and the value of that property must be a member of that type.
Look back at Figure 2.1 again, and consider the relationships labeled type and instances. Arnold is an instance of Person, Actor, and Politician. Person, Actor, and Politician are Metaweb types: they are nodes in the Metaweb graph, but they also impose an object-oriented structure on the graph. Each type defines a set of properties that its instances are expected to have. Each property has a name and a type. An object in a Metaweb database, therefore is a node in the graph, plus the type that it should be viewed as:
Arnold as Person Arnold as Politician
Sex sex: male ElectedOffice office: Governor of CA
Date birthdate: 1947-July-30 Country birthplace: Austria
Next, let's consider Arnold as an Actor. Notice that the list of properties above included three properties named film. This is perfectly fine for a nodes-and-relationships model, but it doesn't fit our object-oriented model where we expect each property to have a single value. A Metaweb type may specify whether each of its properties must be unique or not. For the Actor type, we'd need a non-unique property named film. The type of this property is a set of films that Arnold has acted in:
Arnold as Actor
Set of Film film: [Conan the Barbarian, Kindergarten Cop, Terminator]
Note that the film property is an unordered set of values, not an ordered list of values. If you wanted to display this set of films to an end user, you would most likely want to arrange them into alphabetical order, or by release date. You can ask Metaweb to order them for you, or you can sort them yourself. Some sets, such as the set of tracks on an album have an implicit order, and you can ask Metaweb to return the members of the set in this order. We'll see how to do this in Chapter 3.
All Metaweb objects, regardless of their type or types, define the following properties:
- name
-
This property is a set of human-readable names for the object, suitable for display to the end users of Metaweb. Each name is a /type/text value which holds a string and defines the human language in which it is written. The name property is special in two ways:
-
An object may have more than one name, but may only have one name per language. That is, it can have only one English name, only one French name, and so on.
-
When querying Metaweb, you may treat the name property as if it was a single /type/text value rather than a set of values. Metaweb will automatically return the object's name (if it has one) in your language of choice.
-
- key
-
This property is a set of fully-qualified names for the object. These fully-qualified names are intended for use by developers and scripts and are not typically displayed to end users. Each member of the set is a /type/key value that specifies a namespace object and a name within the namespace. Metaweb guarantees that no two objects will ever have the same fully-qualified name.
- guid
-
Every object in a Metaweb database has a globally unique identifier or guid. The guid property specifies the unique identifier for an object. A guid is a long string of hexadecimal digits following the hash character, and might look like this: #0801010a40005e838000000000019bd2. No two objects will ever have the same value of the guid property. This property is read-only.
- id
-
The id property is used to uniquely identify an object either by its guid, or by a fully-qualified name defined by a key property. If you query the id property of an object, Metaweb usually returns the guid of the object to you. For objects that are instances of core types, Metaweb returns a fully-qualified name (such as /type/text or /lang/en) instead of a guid. Like guid, the id property is unique: no two objects will ever have the same value for this property. This property is read-only. You may not set the id property. (If you add a key property to an object, however, you will be able to refer to the object through a new fully-qualified name.)
- type
-
This property is the set of types associated with the object. The object can be viewed as an instance of any of these types. Each type is itself a Metaweb object, of /type/type.
- timestamp
-
This read-only property is a single value of /type/datetime that specifies when the object was created.
- creator
-
This read-only property is a single link to a /type/user object that specifies which Metaweb user created the object.
- permission
-
This read-only property is a single link to a /type/permission object. A permission object specifies which Metaweb usergroups are allowed to alter the object. See Section 2.6 for more on users, usergroups and permissions.
Notice that four of the eight common properties described above have to do with names and identifiers for Metaweb objects. It is important to understand the difference between human-readable names, fully-qualified names, and guids.
A Metaweb database contains an object that represents the human language English. The name property of this object specifies its human-readable name: "English". Metaweb objects can have only a single name in each language. Our English object might have names "Anglais" and "Ingles" in French and Spanish. It is important to understand that the human-readable name of an object does not uniquely identify it: there may be many other Metaweb objects with the name "English".
Because the name property allows only one name in each language, you cannot use it to specify nicknames for an object. You cannot, for example, give the English object the name "American English" in addition to "English". As we'll see below, most Metaweb objects that are intended for display to end-users are instances of a type called /common/topic. This type defines a property named alias, which you can use to specify any number of nicknames for an object.
The key property of the English object is completely different than the name property. It specifies that the object has the name "en" in a particular namespace object. That namespace object has a key property of its own, which specifies that it has the name "lang" in a special root namespace object. Metaweb uses the slash character to delimit names, so the English object has the fully-qualified name "/lang/en". Fully-qualified names are intended for developers and are often used in code, so we'll usually write them in code font like this: /lang/en.
The critical thing about fully-qualified names is that they are unique. Metaweb ensures that no two objects ever have the same fully-qualified name at the same time.
Human-readable names and fully-qualified names are optional; Metaweb objects are not required to have either. But every object does have a guid value that identifies it uniquely. A unique guid is assigned to an object when it is created, and it never changes. It is always possible to uniquely identify an object by specifying the value of its guid property. The guid of the /lang/en object is "#9202a8c04000641f8000000000000092"
Guids and fully-qualified names are both unique identifiers for objects. The id property is flexible and allows you to use either one. If you want to refer to the English object, you could specify an id property of "#9202a8c04000641f8000000000000092" or "/lang/en".
Objects that are displayed to users of freebase.com are called topics. These are regular Metaweb objects that are members of the type /common/topic in addition to any of their other, more-specific types. /common/topic defines properties that allow descriptions, nicknames, documents and images to be associated with an object, and the freebase.com client uses these properties to assemble an informative web page that describes the object or topic.
All topics in Metaweb are also objects. But not all objects are topics. The distinction is that topics are entries that might be of interest to end users. Objects that are not topics are typically part of the Metaweb infrastructure, and may be of interest to Metaweb developers but not end users. Types, properties, domains and namespaces are not topics, but albums, movies, and restaurants are.
Like many object-oriented programming languages, Metaweb draws a distinction between objects (arbitrary collections of properties) and values (single primitives such as numbers, dates and strings). Metaweb defines nine value types. Like all Metaweb types, value types are identified by type objects. Each type object has a fully-qualified name such as /type/int (for the value type that represents integer values).
Values have a dual nature in Metaweb. Depending on how you ask about them, they may behave like primitives, or like simple objects. If you query a value as if it were an object, then it behaves like a simple object with two properties (as we'll see shortly, two of the value types actually include a third property as well):
- value
-
this property holds the primitive value
- type
-
this property refers to the type object that specifies the type of the value.
If you query a value as a primitive, then just the value of the value property is returned.
The various Metaweb value types are described in the sub-sections that follow. Notice that value types are in the /type domain, and that their names fall under the /type namespace. (We'll see more about namespaces in Section 2.5.)
Values of this type are signed integers. Metaweb uses a 64-bit representation internally, which means that the range of valid values of /type/int is from -9223372036854775808 to 9223372036854775807. An integer literal is simply an optional minus sign followed by a sequence of decimal digits. Metaweb does not support octal or hexadecimal notation for integers, nor does it allow the use of exponential notation for expressing integers.
Values of this type are signed numbers that may include an integer part, a fractional part, and an order of magnitude (a power of ten by which the integer and fractional parts are multiplied.) Metaweb uses the 64-bit IEEE-754 floating point representation which supports magnitudes between 10-324 and 10308. C and Java programmers may recognize this as the double datatype. Metaweb does not support the special values Infinity and NaN, however.
A literal of /type/float consists of an optional minus sign, and optional integer part, and optional decimal point and fractional part and an optional exponent. The integer and fractional parts are simply strings of decimal digits. The exponent begins with the letter e or E, followed by an optional minus sign, and one to three digits. The following are all valid /type/float literals:
1.0 # integer and fractional part 1 # integer part alone .0 # fractional part alone -1 # minus sign allowed as first character 1E-5 # exponent: 1 × 10-5 or 0.00001 5.98e24 # weight of earth in kg: 5.98 × 1024
There are an infinite number of real numbers, and a 64-bit representation can only describe a finite subset of them. Any number with 12 or fewer significant digits can be stored and retrieved exactly with no loss of precision. Numbers with more than 12 significant digits may have those digits truncated when they are stored in Metaweb.
There are only two values for this type; they represent the boolean truth values true and false. Note that Metaweb sometimes uses the absence of a value (null) in place of false.
Values of this type are object identifiers, either guids or fully-qualified names. The object properties guid and id have values of this type.
An instance of /type/text is a string of text plus a value that specifies the human language of that text. The name property of an object is a set of values of this type.
/type/text is unusual. Its value property specifies the text itself, but it also has a lang property that specifies the language in which the text is written. The lang property refers to an object of type /type/lang. The /lang namespace holds many instances of this type, such as /lang/en for English. We'll say more about /type/lang and the /lang namespace later in this chapter.
The text of a /type/text value must be a string of Unicode characters, encoded using the UTF-8 encoding. The encoded string must not occupy more than 4096 bytes. Longer chunks of text (or binary data) can be stored in Metaweb in the form of a /type/content object, which is described later.
Instances of /type/key represent a fully-qualified name. The key property of an object is a set of /type/key values. The value property of a /type/key value is the local, or unqualified part of a fully-qualified name. Like /type/text, /type/key has a third property. The namespace property of a key refers to the /type/namespace object that qualifies the local name. The namespace property and the value property combine to produce a fully-qualified name.
As an example, consider the Metaweb object that represents the value type /type/int. The key property of this object has a value of "int", and a namespace that refers to the /type namespace. The /type namespace is also an object, and its key property has a value of "type" and a namespace that refers to the root namespace object.
The value property of a key must be a string of ASCII characters, and may include letters, numbers, underscores, hyphens and dollar signs. A key may not begin or end with a hyphen or underscore. The dollar sign is special: it must be followed by four hexadecimal digits (using letters A through F, in uppercase), and is used when it is necessary to map Unicode characters into ASCII so that they can be represented in a key. To represent an extended Unicode character (that does not fit in four hexadecimal digits), encode that character in UTF-16 using a surrogate pair, and then express the surrogate pair using two dollar-sign escapes.
Keys used as names for domains, types and properties are further restricted: they may not include hyphens or dollar signs, and may not include two underscores in a row.
A value of /type/rawstring is a string of bytes with no associated language specification. The length of the string must not exceed 4096 bytes.
Use /type/rawstring instead of /type/text for small amounts of binary data and for textual strings that are not intended to be human readable.
An instance of /type/uri represents a URI (Uniform Resource Identifier: see RFC 3986). The value property holds the URI text, which should consist entirely of ASCII characters. Any non-ASCII characters, and any characters that are not allowed in URIs should be URI-encoded using hexadecimal escapes of the form %XX to represent arbitrary bytes.
An instance of /type/datetime represents an instant in time. That instant may be as long as a year or as short as a fraction of a second. The value property is a a string representation of a date and time formatted according to a subset of the ISO 8601 standard. /type/datetime only supports dates specified using month and day of month. It does not support the ISO 8601 day-of-year, week-of-year and day-of-week representations.
A /type/datetime value that represents the first millisecond of the 21st century looks like this:
2001-01-01T00:00:00.001Z
Notice the following points about this format:
-
Longer intervals of time (years, months, etc.) are specified before shorter intervals (minutes, seconds, etc.).
-
Years must be specified with a full four digits, even when the leading digits are zeros. Negative years are allowed, but years with more than four digits are not allowed.
-
Months and days must always be specified with two digits, starting with 01, even when the first digit is a 0.
-
The components of a date are separated from each other with hyphens.
-
A date is separated from the time that follows with a capital letter T.
-
Times are specified using a 24-hour clock. Midnight is hour 00, not hour 24. Hours and minutes must be specified with two digits, even when the first digit is 0.
-
Seconds must be specified with two digits, but may also include a decimal point and a fractional second. Metaweb allows up to 9 digits after the decimal point.
-
The hours, minutes, and seconds components of a time specification are separated from each other with colons.
-
A time may be followed by a timezone specification. The capital letter Z is special: it specifies that the time is in Universal Time, or UTC (formerly known as GMT). Local timezones that are later than UTC (east of the Greenwich meridian) are expressed as a positive offset of hours and minutes such as +05:30 for India. Local times earlier than UTC are expressed with a negative offset such as -08:00 for US Pacific time. If no timezone is specified, then then the /type/datetime value is assumed to be a local time in an unknown timezone. Specifying a timezone of +00:00 is the same as specifying Z. Specifying -00:00 is the same as omitting the timezone altogether.
-
All characters used in the /type/datetime representation are from the ASCII character set, so date and time values can be treated as strings of 8-bit ASCII characters.
A /type/datetime value can represent time at various granularities, and any of the date or time fields on the right-hand side can be omitted to produce a value with a larger granularity. For example, the seconds field can be omitted to specify a day, hour, and minute. Or all the time fields and the day-of-month field can be omitted to specify just a year and a month. Also, the date fields can be omitted to specify a time that is independent of date. A timezone may not be appended to a date alone: there must be at least an hour field specified before a timezone.
Here are some example /type/datetime values that demonstrate the allowed formats:
2001
# The year 2001 2001-01
# January 2001 2001-01-01
# January 1st 2001 2001-01-01T01Z
# 1 hour past midnight (UTC), January 1st 2001 2000-12-31T23:59Z
# 1 minute before midnight (UTC) December 31st, 2000 2000-12-31T23:59:59Z
# 1 second before midnight (UTC) December 31st, 2000 2000-12-31T23:59:59.9Z
# .1 second before midnight (UTC) December 31st, 2000 00:00:00Z
# Midnight, UTC 12:15
# Quarter past noon, local time 17-05:00
# Happy hour, Boston (US Eastern Standard Time)
Types that are not value types are object types. Metaweb pre-defines a number of object types, organized into domains of related types. Metaweb users are allowed (and encouraged) to define new object types as needed. Pre-defined object types can be categorized into the core types that are part of the Metaweb infrastructure, common types that are used commonly throughout Metaweb, and domain-specific types. The core types are all part of the /type domain (which they share with the value types), and the common types are all part of the /common domain. freebase.com defines many domain-specific types, such as the music-related types /music/artist, /music/album and /music/track. Figure 2.2 illustrates these type categories.
Figure 2.2. Categories of Metaweb types
+--/type/id
+--/type/int
+--/type/float
+--/type/boolean
+--Value Types
----- +--/type/text
+--/type/rawstring
+--/restaurant domain
+--/type/uri
+--/location domain
+--/type/datetime
+--/film domain
+--/music/track Types
+--/type/key
+--/music domain
+--/music/album
+--Freebase Types-----
+--/book domain
+--/music/artist
+--etc.
+--Object Types-
+--Core Types (/type domain)
+--Common Types (/common domain)
+--User-defined Types
The sub-sections that follow introduce the most important core and common types. You do not need to understand these types in detail in order to make productive use of Metaweb. Still, knowing what these basic types are is a helpful orientation to the system.
Types, Properties, domains and namespaces are fundamental to the Metaweb architecture, but are represented by ordinary Metaweb types. These most fundamental types are described below.
Earlier in this chapter, we explained that all Metaweb objects share a set of common properties: name, id, key and so on. These universal object properties are defined by a core type named /type/object. If you are an object-oriented programmer familiar with languages such as Java, you might guess that /type/object is the root of the type hierarchy, and that it is the superclass of all other object types.
In fact, however, Metaweb does not have a type hierarchy. Types do not have supertypes. /type/object is not a normal type. Objects are never declared to be instances of this type. Remember that one of the common object properties is type: it specifies a set of types for the object. /type/object never needs to be a member of this set. In fact, an object's set of types can be empty, and the object will still have all of the common properties. The /type/object type exists simply as a convenient placeholder. It serves to group the /type/property objects that represent the common object properties.
This type describes a type, which means that it is the only type that is an instance of itself. Types have five properties:
- properties
-
The set of properties defined by the type.
- instance
-
The set of instances of the type. For commonly used properties, this set may obviously grow quite large. Recall, however that all relationship between objects in Metaweb are inherently bi-directional. Since every object has a type property that refers to its type, it follows that every type has a set of incoming links from its instances. Thus, every type automatically maintains a set of its instances.
- domain
-
The domain to which the type belongs
- expected_by
-
The set of properties whose value is of the type
- default_property
-
The name of the default property for the type. When you ask Metaweb to return an object as if it were a primitive value, Metaweb returns the value of the default property for that type. For value types, the default property is value. For most object types the default property is name. And for core types in the /type domain, the default property is id.
Every type defines a set of properties for its instances. The members of this set are /type/property objects. The common name and key properties of a property object specify the human-readable and fully-qualified names for the property. In addition, properties specific to /type/property specify:
-
The expected type of the value of the property
-
Whether the property is unique. A unique property may only have a single value (or may have no value). A property that is not unique has a set of zero or more values.
-
The reciprocal property, if there is one.
-
The type of which this property is a part.
The notion of a reciprocal property deserves more explanation. Recall that all links in Metaweb are bi-directional. This means that any time a property of type A refers to an object of type B Metaweb automatically has a link from that object of type B back to the originating object of type A. Type B can take advantage of this bi-directionality and include a property that links back to objects of type A. As a concrete example, consider the properties property of /type/type: it specifies the set of properties for a type. Its reciprocal is the schema property of /type/property, which specifies the type object (or "schema") of which the property is a part. You'll find further exploration of reciprocal properties in Chapter 5.
A domain represents a set of related types, and also serves as a namespace for those types. For access control purposes, each domain object refers to one or more usergroup objects that "own" the domain. Only members of the specified usergroups are allowed to add new types to the domain or to edit types within the domain.
The following types from the /type and /common domains are important content-related types:
- /type/content
-
Large chunks of content, such as HTML documents and graphical images are not stored in regular Metaweb nodes. Instead, these large objects (sometimes called lobs) are kept in a separate store. A /type/content object is the bridge between the Metaweb object store and the Metaweb content store. A /type/content object represents an entry in the content store, and the guid of the /type/content object is used as an index for retrieving the content.
In addition to providing access to the content store, /type/content defines important properties. The media_type property specifies the MIME type of the content. For textual content, the text_encoding and language properties specify the encoding and language of the text. The length property specifies the size (in bytes) of the content. The source property refers to a /type/content_import object that specifies the source of the content.
Chapter 4 shows how to download content from Metaweb, and Chapter 6 demonstrates how to upload content.
- /type/content_import
-
This type describes the source of imported content. Its properties include the URI or filename from which the content was obtained, the user who imported the content, and a timestamp that specifies when the content was imported.
- /type/media_type
-
Instances of this type represent a MIME media type such as "text/html" or "image/png". Instances are given fully-qualified names within the /media_type namespace, and can be specified with ids like /media_type/text/html or /media_type/image/png.
- /type/text_encoding
-
Instances of this type represent standard text encodings, such as ASCII and Unicode UTF-8. Instances are given fully-qualified names within the /media_type/text_encoding namespace, and can be specified with ids such as /media_type/text_encoding/ascii.
- /type/lang
-
This type represents a human language. It is used by /type/content objects and also by /type/text values. Pre-defined instances of this type are given fully-qualified names within the /lang namespace, and can be specified with ids like /lang/en and /lang/fr.
- /common/topic
-
As described earlier in this chapter, Metaweb objects that are intended for display to end users are called "topics". Such objects typically have some appropriate domain-specific type, such as /music/artist or /food/restaurant, but are also instances of the type /common/topic. This type defines properties that allow documents and images to be associated with the topic. Another property allows a set of URLs to be associated with the topic. Also, because objects can only have a single name in any given language, /common/topic has an alias property that allows any number of nicknames to be specified for the topic.
- /common/document
-
This type represents a document of some sort. /common/topic uses this type to associate documents with topics. The most important property is content, which specifies the single /type/content object that refers to the document content. Other properties of /common/document provide meta-information about the document, such as authors, publication date, and so on.
- /common/image
-
/type/content objects that represent images are typically co-typed with this type. /common/image defines a size property that specifies the pixel dimensions of the image.
The following types are part of the Metaweb access control framework.
- /type/user
-
Each registered Metaweb user is represented with an object of /type/user. User objects have fully-qualified names in the /user namespace. If your username is joe_developer, then your /type/user object is /user/joe_developer.
- /type/usergroup
-
This type represents a set of users.
- /type/permission
-
This type is the key to Metaweb access control. Its properties specify the set of objects that require this permission for modifications, and also the set of usergroups that have the permission. See Section 2.6 for further details.
A domain is a Metaweb object of /type/domain. It represents a collection of related types. We've already seen a number of types from the /type and /common domains. freebase.com pre-defines types in a number of general domains, and Chapter 3 and Chapter 4 feature many examples using the Freebase /music domain. The set of Freebase domains is expected to grow, but at the time of this writing, it includes:
/business /food /measurement_unit /education /language /music /film /location
As you might guess from the names of these domains, domain objects are also instances of /type/namespace, and the types contained by domains are members of both the domain and the namespace.
Every Metaweb user who registers for an account has their own domain. If your Metaweb username is fred, then your domain is /user/fred/default_domain. When you use the freebase.com client to define a new type named Beer, it is given the id /user/fred/default_domain/beer. If your type becomes an important and commonly used one, it may be promoted by Metaweb administrators to a top-level domain. In this case, your type might be given a new fully-qualified name like /zymurgy/beer.
Namespaces are a critical part of the Metaweb infrastructure because they allow us to refer to important objects, such as types, with simple mnemonic names rather than opaque guids. It would be very inconvenient to query Metaweb if we had to write "#9202a8c04000641f8000000000000565" instead of "/common/topic", for example.
We've already learned about a number of important namespaces including /type, /user, /lang, and /media_type. In addition to these, each domain and user object is also a namespace. Also, there is the root namespace, whose id is simply /.
A number of important namespaces are populated with pre-defined objects using names defined by international standards. The languages in the /lang namespace use language codes (such as "en" for English and "fr" for French) defined by ISO 639. The media types in /media_type are defined by IANA and listed at http://www.iana.org/assignments/media-types/. And the text encodings in /media_type/text_encoding use names defined by IANA at http://www.iana.org/assignments/character-sets.
Metaweb is completely open for reading. Anyone who can connect to Metaweb servers can read data from them. When adding or editing data, however access control comes into play. We've already seen that the types /type/user, /type/usergroup, and /type/permission are used for access control.
Metaweb's access control model is quite simple. Every object has a permission property that refers to a /type/permission object. The permission object specifies a set of usergroups whose members have permission to modify the object. If a user is a member of one or more of the specified groups, then that user can edit the object. Otherwise, the user is not allowed to.
This simple access control model is, by default, also very open. In order to allow and encourage free collaboration most Metaweb objects have a permission object that gives edit permission to all Metaweb users. If Metaweb user Fred creates a new object, his friend Jill can freely edit that object. Any other Metaweb user can edit the object as well, and there is no way for Fred to restrict the permission on his object.
The primary exception to this open access control model is type objects. Having a stable type system is very important. Each domain has a usergroup associated with it, and only members of that usergroup can create new types in the domain or alter existing types in the domain. Each user account has an associated domain. Fred's domain is /user/fred/default_domain. This domain has an associated usergroup. Initially, Fred is the only member of this group. He is allowed to add to the usergroup, and if he adds his friend Jill, then she is permitted to create new types in Fred's domain.
Other key parts of the Metaweb infrastructure also have restrictive access control, of course. Ordinary users are not allowed to insert objects into the /lang namespace or the /type domain, for example.
