<> a :RoughGuide; :to :Notation3 .

Notation3, or "N3" as it is more commonly known, is a shorthand non-XML serialization of RDF, designed with human-readability in mind. According to the Notation3 Specification, it was created as an experiment in optimizing the "expression of data and logic in the same language".

The format is being developed by Tim Berners-Lee, with input from Dan Connolly at al.

Apart from the DesignIssues Notation3 specification, the only other substantive piece of documentation—and by far the most popular—is the Notation3 Primer, which is maintained alongside the main N3 codebase.

N3 has been well received for its "scribblability", because it is much more compact and readble than XML RDF, and because it forms a good introduction into many key principles of the Semantic Web.

Some people are opposed to N3, however, because the stability of the language in the long term is not known, there are some i18n issues (which are being resolved), and a notable lack of analogies for various features of N3 in XML RDF.


Implementations—Grammars and Other Tools

At the moment, the best tools for Notation3 are available in Python. The so called Semantic Web Area for Play (SWAP) is the development page for most of these, linking to Notation3.py and CWM (pronounced "coom", with a short "oo"!). There are some other minor tools as well, for example the tab delimited to Notation3 python hack.

DesignIssues: Notation3 - TimBL. Language: BNF.
Old notation3.py - DanC. Language: Python.
SWAP: notation3.py - DanC/TimBL. Language: Python.
Euler - Jos De Roo. Language: Java.
SWAP: n3spark.py - DanC. "a re-implementation of RDF/n3 syntax using the SPARK tools". Language: Python/SPARK.
SWAP: rdfn3.g - DanC. "a Yapps grammar for RDF Notation 3" cf. Python file, HTML file - "RDF Notation3 Grammar", in XHTML. Language: Python/Yapps.
flaten3: lexer.l - Sandro. Language: C/Lexx.
blindfold n3.bnf - Sandro. Language: BNF.
Cwmclone.P. - Bijan Parsia. Language: Prolog.
RDF::Notation3/Notation3.pm - PCIMPRICH. Language: Perl.
Eep: n3.py - Sean B. Palmer. Language: Python.
n3s - A Notation3 Preprocessor - Sean B. Palmer. Language: Python.
RDF For Little Languages: N3 Parser - Graham Klyne. Language: Python.
Afon N3 Parser - Sean B. Palmer. Language: Python.

I did a long survey of local N3 grammars, culminating with The Great QName Survey; the survey exposed the great inconsistencies between the various implementations of N3.

Closed World Machine

Closed World Machine is a query machine for Notation3 that recognizes a few logical primitives. CVS for CWM and the related modules, the SWAP main page, the official CWM documentation, and my own guide to CWM are available.


Try SWAP: Notation3 examples and test (CVS). The SWAD page links to some more.


The regression test and associated N3 files still remain the best N3 test suite to date.

N3 Intermediate FAQ

The following are some issues that people run into when they've been playing with N3 for a while, and aren't addressed in the Notation3 specification or the Primer. A level of understanding compatible with those who have read the N3 Primer is required for some of these FAQs.

What MIME type does N3 have? How can I tell whether a file is N3 or not?

Good questions. TimBL has noted several times—including in the DesignIssues document, #rdfig, and the SWAP code—that Notation3 should have the MIME type "application/n3". However, this MIME type has not been registered, and as far as I know, no N3 files are currently served from an HTTP server using this MIME type.

As for telling whether something is an N3 file, this is also a difficult thing to do, although sniffing for strings such as "@prefix" and "<#>" give you a fairly good indication. Also, if the following is the first line of a file, then you can be fairly sure that it's N3:-

<> a <http://www.w3.org/2000/10/swap/log#N3Document> .

Caution! These are heuristics only. CWM used to search for the string "xmlns" in a file to determine whether it was XML/RDF or Notation3. It decided that all files with "xmlns" in them were XML. This worked quite well until Dan Brickley decided to buy the xmlns.com domain name, and use it for the namespace of his highly popular FOAF application—as you can guess, this caused CWM to break.

The standard file extension for N3 is ".n3".

What are the () things in N3 files? What do they have to do with DAML Lists?

You may often see things like the following:-

:Bob :brothers (:Jim :Mark :Ian) .

The parenthetical expression is a DAML list, and is equivalent to:-

[ daml:first :Jim; 
  daml:rest [ daml:first :Mark; 
              daml:rest [ daml:first :Ian; 
                          daml:rest daml:nil ] ] ] .

as you can tell, the shorthand syntax is very useful indeed. Note that daml:nil (which is neither a property nor a class) is the term for the empty list: ().

What is the :- token used for?

The ":-" token is a bit of syntax that de-anonimizes a blank node. For example, the following:-

[ :- :x; :y :z ] .

is just a syntactic "shortcut"—and therefore completely equivalent to—the following (noting that the [] returns an anonymous node):-

:x :y :z .

This method can be very useful when, for example, wanting to carry on statements where the object of one triple is the subject of another triple.

:W3C :homepage [ :- <http://www.w3.org/>; 
                 :title "Homepage of the W3C" ] .

Quoth DanC:-

21:27:11 <DanC> on :- ... I restricted it to { :tim knows [ :- :dan; a :CoolGuy.]}.
21:33:09 <DanC> here's the example that motivated my :- hacking:
21:33:10 <DanC> :libby :says
21:33:10 <DanC>   { :dan :says
21:33:10 <DanC>     { [ :- :her; is :ex of :dan ] [ rdfs:subPropertyOf :told; :to :dan]
21:33:11 <DanC>       { [is :mom of [ is :friend of :her]] :workedFor :theNation }
21:33:11 <DanC>     } }.
21:33:21 <DanC> # libby says that dan says that dan's ex's told him that a friend's mom 
used to work for the nation
- http://ilrt.org/discovery/chatlogs/rdfig/2001-04-19.txt

Note, by the way, that this could have been expressed as:-

:libby :says
  { :dan :says
    { :her is :ex of :dan; [ rdfs:subPropertyOf :told; :to :dan ]
      { [ is :mom of [ is :friend of :her ] ] :workedFor :theNation }
    } }.

Personally, I'd prefer using an "iso" keyword instead of ":-".

What's the Difference Between <> and this?

<> always refers to the URI of the containing document. "this" is a keyword that identifies the root formula of the document; the relationship between the two can be expressed as:-

<> log:semantics this .

The two are by no means equivalent. <> will always identify some kind of document, and "this" will always identify a set of statements, i.e. a formula.

Note that quantification in N3 was previously achieved by quantifying over the document, but is now achieved by quantifying over the root formula. These changes were all documented in TimBL's email.

The main effect of this is that where one has said "<> log:forAll :x, :y,
:z" one must use the keywpord "this" instead of "<>" to refer to the current
context instead of the current document.
The parsers currently generate an id "#_formula" for the context but one
must NOT rely on that.

Note that CWM has a habit of reserving fragment IDs within the current document for its own purposes! It appears from the llyn.py source code that "$" was considered for a while instead of the keyword "this":-

- Introduce this or $ to indicate the current context
- Introduce a difference between <> and $  in that <> log:parsesTo $ .
    serialised subPropertyOf serialisedAs
- llyn.py,v 1.32 2002/07/24 02:31:39

[Note also that log:parsesTo was renamed log:semantics (it was log:resolvesTo for a while, and still works using that property in cwm.py v 1.97 2002/07/06).]

How does one label formulae?

(cf. the definition of formulae in the N3 primer).

I've found that it's quite easy to get along without having URIs for formulae, but on the other hand APIs often need to be able to associate a formula with (perhaps) the location of the document that the formula was obtained from. CWM does this by using the fragment ID #_formula in the document. This results in breakages when #_formula is being used for something else, and CWM shouldn't really reserve terms in that way.

[...] Can they [formulae] be given an id? You can assert that any object is equivalent to (=) a given context. However, it is the contexts which define a context. If one could label it in one place then one would want to be able to label it in more than one. I'm not sure whether this is wise. Let's try it with no IDs on contexts as in the N3 syntax. There would be the question of in which context the assertion wa made that the URI was a label for the expression. You couldn't just treat it as part of the machinery as we do for URI of a regular thing.
- cwm.py v 1.25 2001/01/30

CWM has also been known to output triples such as:-

    <blargh.n3#_formula> :- {
        this     log:forSome <blargh.n3#_gy> .
        <blargh.n3#x>     <blargh.n3#_gy> "z" .
        } .

Which implies that :- can be used to label formulae using the URI for the subject and the contents for the object. However, CWM hasn't produced this sort of output for quite a while (since around cwm.py v 1.82 2001/11/15), and note that when you feed something like that back through it, it doesn't like it:-

$ n3s -s ':x :- { :p :q :r }' | cwm
#Processed by Id: cwm.py,v 1.97 2002/07/06 12:52:02 timbl Exp 
        Traceback (most recent call last): [...]
  File "/home/newswap/2000/10/swap/llyn.py", line 1087, in storeQuad
    if context.statementsMatching(pred, subj, obj):
AttributeError: Fragment instance has no attribute 'statementsMatching'

How do I do OR and NOT in N3?

Well, theoretically, RDF is just an ANDing of lots of statements, and if we introduced NOT we could NAND our way into an OR construction... but other methods have been suggested.

Check out: Semantic Web Toolbox, and:-

<sbp> how would you express OR now? I thought of using an Alt bag (I 
thought was was what it was meant to do), e.g. [ a rdf:Alt; rdf:_1 { :Bob 
a :Fish }; rdf:_2 { :Bob a :Dog } ] .
<tim> I would say something like ( :F :G :H ) a :OR.

#rdfig 2001-11-21

Why is @prefix required? Couldn't this be part of the model?

The @prefix directive in Notation3 is required by a parser when using QNames, the proof being that using directives in the RDF graph is not a suitable alternative. Here are a list of the suggested alternatives, and reasons why they don't work:-

First idea: one could declare a unique and unambiguous subproperty of rdfs:label to use for labelling namespaces with a literal.

   u:nsLabel a daml:UniqueProperty, daml:UnambiguousProperty;
      rdfs:subPropertyOf rdfs:label; rdfs:range rdfs:Literal .

however, this won't scale since it:-

In any case, the @prefix directive in Notation3 is a local thing, and there's no reason why a binding in the graph shouldn't be associated with a specific document:-

   <> u:usesNamespaceBinding ("rdfs" <http://.../rdf-schema#>) .

Here, consider that u: itself must be bound to a "special" namespace in order for it to be recognized.

   <> u:usesNamespaceBinding ("u" <http://.../n3syntax#>) .

An N3 processor would need to parse and extract the information from the document in order to parse and extract the information from the document (in order to...). In other words, you can't go putting information in the graph that is vital to the parsing and correct interpretation of the document.

The alternative here is to use a special Notation3 keyword for the binding:-

   <> usesNamespaceBinding ("rdfs" <http://.../rdf-schema#>) .

the next problem that comes up is the old Semantic Web issue of where to find the information. Suppose that in document <a.n3> you have:-

   rdfs:comment rdfs:label "comment" .

and in <b.n3> you have:-

   <a.n3> usesNamespaceBinding ("rdfs" <http://.../rdf-schema#>) .

It fails for the obvious reason: the information about namespace bindings must always be available to the parser at parse time. One could come up with a usesNamespacesDeclaredInFile(s) keyword, but its use would have to be required, and that would be unenforcable and far more trouble than it's worth.

Can I override the "_" prefix used for bNodes?

In CWM, you can. For example:-

$ echo '@prefix _: <#> . _:x _:y _:z .' | cwm
#Processed by Id: cwm.py,v 1.97 2002/07/06 12:52:02 timbl Exp 

     @prefix : <#> .
    :x     :y :z .

However, whether this should be standard for N3 is not clear. This is one of the many little implementation points of N3 where one just has to "guess", or survey the range of existing implementations and grammars. The Design Issues Notation3 "specification" lists "_" under prefix, with the note "(special ntuples hack. Everything in _ namespace is implictly existentially qualified at the outermost scope)". In fact, whether _:x style bNodes are quantified over the outermost scope or just their parent scope is also a point of some contention.

What does the log:rawType built-in do?

log:rawType gives the type of a subject as a node. For example, CWM would be happy with these triples (more precisely: they would be evaluated as "true" in a rule antecedent):-

"x" log:rawType log:String .
<#x> log:rawType log:Other .

It is a magic predicate, and breaks when you feed in rules about DAML equivalence. Observe:-

$ n3s -s '{ ?p = ?x . ?p ?q ?r } => { ?x ?q ?r } . { ?x = ?y; 
log:rawType ?z } => { ?x :rawType ?z } . "blargh" = <#x> . 
<#x> = "blargh"' | cwm --think
#Processed by Id: cwm.py,v 1.99 2002/07/31 23:19:26 timbl Exp 

    "blargh"	:rawType log:Literal, log:Other; 
                  = "blargh", :x .
    :x     :rawType log:Literal, log:Other;
           = "blargh", :x .

unless log:Literal and log:Other are considered to intersect, which is inconsistent with the way that log:rawType is evaluated in rule antecedents.

For this reason, you should only use this property (and its cousins: log:uri, log:racine, and log:stringOutput) with caution and a pinch of salt.

Is Notation3 isomorphic with XML RDF?

In a word: no. There are various features of Notation3 that are not present in XML RDF. Here's GabeW and DanC on the subject:-

#rdfig, 2001-04-15, 04:47:01

Proposed Features

Also: Alternative design choices in Notation3.

RDF Path

"RDF Path" is TimBL's joke name for being able to traverse graphs by reducing the syntax required for chaining sets of statements together with anonymous nodes. For example:-

"Le Petit Prince"^:fr^:title.:author :name "Fred" .

is short for:-

[ is :author of [ :title [ :fr "Le Petit Prince" ] ] ] :name "Fred" .

Personally, I think that the syntax offers little in the way of advantage to users, and is quite a burden on N3 parsers. I spent a while implementing it in afon, and I think that even the advantage of LTR parsing over RTL is not all that evident. I prefer "$" and "%" to "." and "^". Tim prefers the latter. In a perfect (i.e. bijan dominated) world, we'd all be using parens, apparently. BTW, the scary ':boss$:wife$:age = "7" .' example from the 2002-07-17 #rdfig logs was a result of reducing a larger test case and not realising the new semantics; think of the age in dog years, perhaps.

@prefix default, @keyword, and @use

The @keyword, @use and @prefix default declarations allow one to carve out a space of keywords in a particular Notation3 file. Notation3 already reserves some keywords, such as "a", and "this". It also has a number of non-name component symbols such as "=" and ":-" etc. The new declarations enable one to extend the keywords in a consistent manner, but do not allow you to add new non-name component symbols.

The @keyword declaration would let the parser know which keywords from the default N3 space the user wants to use. The @use declaration would enable one to import a keyword from a namespace. The @prefix default construct would simply let people say that any keywords that aren't declared in the @keyword or @use spaces are in this space. Actually, "@prefix default" used to be a part of Notation3, but was removed.

There would be a particular cascade (order of precedence) for the keyword spaces. In decending order of importance:-

For example:-

@keyword this, blargh . 
@use this, x, y  . 
@prefix default  . 

this a blargh . 
x y z .


@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .

this rdf:type blargh . 
<http://xyz.org/#x> <http://xyz.org/#y> <http://blargh.org/#z> .

@keyword, @use, and @prefix default have been implemented in the N3S Notation3 Preprocessor, which is a good demonstration of how they should work.

?x syntax for universally quantified variables

_:x was proposed by DanC as a method of labelling existentially quantified nodes, and ?x was proposed soon afterwards (by either DanC or AaronSw). It was first implemented in the Yapps N3 grammar, and recently became part of the main SWAP code: notation3.py,v 1.118 contains "def variable".

=> and <=> as special syntax

It has been proposed that => could be used as a syntactic abbreviation of log:implies, and <=> likewise for log:means. (@@ references)

Alternative quantification syntaxes

The log: (http://www.w3.org/2000/10/swap/log#) namespace contains various various terms that are important to N3 (for example, log:N3Document is the class of N3 documents). However, it goes even further than this by setting out the log:forSome and log:forAll properties which can be used to quantify terms in an N3 document. They are syntactic devices that somehow found their way into the model, and produce triples that break many fundamental axioms.

Here, then, are some alternatives that have been proposed:-

@forAll @forSome

DanC's idea, taken in favourably by TimBL. It looks likely that this will be implemented in CWM fairly soon.

2001-09-07 16:51:08 <DanC> C:issue: N3 quantifiers masquerade as normal 
triples. If this interpretation is (decided to be) right, that's misleading. 
something like @forAll :x. (or just ?x) is more transparent

and from 2002-06-27 15:25:11:-
15:25:11 <timmmit> N3 changes ..... -=> for log:implies, @forAll, @forSome
<sandro> n3 should have => (implies) and ?x univars and !x exivars
<timmmit> Restriction to declare variables first in that order in anycontext
<AaronSw> !x? why not _:x
<timmmit> Problem: What is the scope of a variable's quantification?
<sandro> Because _:x is file-scope, but !x is scoped by the implies [...]
<timmmit> Proposal from sandro as seen by tim: ?x means x where the parent of this forall x.
<timmmit> Implict "foral"" at eth level above this one.
<timmmit> Whereas !x has an implict forall at this level. [...]
<timmmit> _: isonly usied inntriples wherethe question does not occur.
<sandro> But maybe no one is using _:a inslde {...} in n3 now, in which case we could use it.
15:29:11 <sandro> My proposal is that pt1:implication closes the scope of ?x and !x (the ? has scope of both halves, the ! has scope of each half).

- #rdfig

My 2c on this issue is that !x is not required, and if it was, then you'd need to introduce a *x or whatever to take the same role up with univars. It would be easiest to say that ?x is quantified over its parent formula unless there is a "@forAll ?x ." directive to the contrary in a different level. Same goes for _:x.

forAll/forSome Keywords

It has been proposed (@@ where? I think I proposed this, but it could have been someone else) that forSome and forAll keywords could be used instead, but with the emergence of the ?x syntax for universally quantified variables, the quantification properties/keywords may evenually become obsolete.


Would only work if formulae/contexts weren't anonymous.

_:x :- { :x :y ?(_:x)z } .

Since parentheses already denote DAML lists, it would make tokenization a little trickier, though not impossible.


@comment would force a comment in the sink: useful for debugging and so forth, but annoying when linking in external documents, or recursively processing a single document.

Typed Literals

These found their way into N-Triples (in the guise of XML literals), and now they're slowly creeping into Notation3.

<tim_lap> I want date and numeric literals in N3 eventuyally.

#rdfig 2002-08-07


:Jenny :age 10 .
:Conference :when date"2000-08-05" .


Notation3 Macros

This isn't really a proposed feature; more of a silly proposed built-in function for CWM, to make writing Notation3 just that bit easier for the author, and a bit more confusing for everyone else.

All you need for this little trick is string interpolation.

# Declare a macro

:Blargh :macro """[ :name "%s" ] .""" .

# Show an example using the macro

"Bob" :useMacro :Blargh .

# Rule to make the macro work

{ ?x :useMacro [ :macro ?y ] . 
  (?y ?x) s:itpl [ log:n3ExprFor ?s ] . 
  ?s log:includes { ?p ?q ?r } } log:implies { ?p ?q ?r } .

:macro a log:Chaff .
:useMacro a log:Chaff .

Here's the Python for the s:itpl property:-

class BI_Itpl(LightBuiltIn, Function): 
    def evaluateObject(self, store, context, subj, subj_py): 
        str, itpl = subj_py

        def flatten(c):
            if isString(c): return [c]
            r = []
            for item in c: 
                if isString(item): r.append(item)
                else: r.append(flatten(item))
            return r

        itpl = tuple(flatten(itpl))
        if len(itpl) == 1: itpl = itpl[0]

        return store._fromPython(context, str % itpl)

Deprecated features

Note that technically, some of the proposed features above like "@prefix default" are in fact old features of N3 that were taken out and are now being reconsidered.


"bind" is a directive keyword very similar to "@prefix", except that it appends a hash ("#") to every single namespace. Therefore, the following Notation3:-

bind t: <http://xyz.n3/> .
:x :y :z .

results in the following triples:-

<http://xyz.n3/#x> <http://xyz.n3/#y> <http://xyz.n3/#z> .

The rationale for the design of "bind" most likely comes from TimBL's belief that all HTTP namespaces should end with a hash. However, this means that (for example) Dublin Core and FOAF terms would be impossible to abbreviate—along with non-HTTP URIs of all sorts.

>- and ->

">-" and "->" were old bits of redundant syntax included in the original proposal to make N3 more readable, and to model the arcs that people would draw on whiteboards. They were officially removed from the syntax on 2001-11-27 due to feedback from bijan, mnot, and DanC in #rdfig:-

23:55:14 <bijan> >-label->!!!
23:55:21 <bijan> I *never* got that until *just now*!
23:55:37 <bijan> I thought it was two operators!
23:55:40 <timbl> :) ooops Then everyone found the version without the >- ..-> was actually readable too. [...]
23:55:50 <timbl> So they kinda dropped out of use. [...]
23:57:25 <timbl> Hmmmm ... I sense we have a consensus on the channel to kill the arrow heads nd tails.
23:57:31 <mnot> .. and then SAY they're dead (perhaps in DesignIssues/Notation3 and/or the tutorial?)
23:57:40 <bijan> indeed! Purify the Grammar! [...]
23:59:05 <timbl> obsoleted in DesignIssues/Notation3

' for URI-refs

5. Use <> for URIs uinstead of ' - DanC.
Alternative design choices in Notation3

I presume from that that URI-refs used to be delimited with either a single leading apostrophe, or leading and trailing apostrophes. For example:-

'http://www.w3.org/ '#title "The World Wide Web Consortium" .

History of the Syntax

No one (except TimBL) is quite sure when Notation3 was invented—the DesignIssues document says "Date: 1998", but the earliest version in the Alexa Web Archive only dates back to 2001-01-21. The document was definitely there in November (Thursday, November 09, 2000) when I first came across the language, but my copy of the document didn't save correctly—and the next oldest version that I have is from January.

The first ever mention of Notation3 in public was in the announcement to www-rdf-logic, 13 Oct 2000 16:17:13 -0500 by DanC. DanC's KB "$Revision: 1.2 $ of $Date: 2000/10/14 15:11:04 $ by $Author: connolly $", mentions the Notation3 homepage. The oldest N3 file ("bind : <> .\n:a :b :c .") that I know of is in the SWAP stuff (from Tue Oct 31 19:19:39 2000; CWM dates from Thu Nov 16 16:43:49 2000).

DanC used N3 in his .sig from about 13-Oct-2000 to 9-Nov-2000. However, Notation3 could date from as early as July of 2000, according to the documentation of an early version of Notation3.py:-

Date: 2000/07/17 21:46:13  

Notation3 is also mentioned in DAML Scribblings—a file on the W3C server that was created in 2000-07, and hasn't been updated since "$Date: 2000/08/11 18:41:06 $". It contains the list item: "whiteboard ASCII syntax??? Notation3? Metalog? namespace-kif? (DC against?)".

TimBL spoke briefly about Notation3's origins (and possibly explained the phrase "whiteboard ASCII syntax" in the DAML scribblings document) on #rdfig:-

23:54:30 <timbl> Lists I'm not very happy with.
23:54:48 <timbl> The >-   ->   was syntac deisgned to look like 
circles and arrows on a whiteboard.
23:54:54 <timbl> People kept doing it in IRC.
23:55:03 <timbl> So N3 was first a syntax for that.
- #rdfig

How N3 Got Its Name

Called Notation3 because RDF M&S was the first, the RDF strawman was the second and this is the third.

RDF IG F2F 2001-02-26, Sun, 11 Mar 2001 06:52:30 UTC

The Strawman simpler syntax for RDF is part of the DesignIssues series, and dates from circa 1999.


The syntax for Notation3 basically changes with the seasons. Whilst TimBL is the main authority on the language, everybody interprets the language in their own way, adding and removing constructs. Even TimBL has changed the language a fair amount of times, and is receptive to feedback on the language in general.

The main change in N3 was the introduction of "this" as a keyword to denote the root formula.

N3 Changes - TimBL
Addition of "this" as a keyword, Change of namespaces

Dropping the redundant colon was a big thread.

Comments, Criticisms, and Praise for Notation3

Bjoern Hoehrmann has criticized the lack of a solid Notation3 specification, in his Notation3 woes message ("I'm not happy with available materials on Notation3").

OTOH, David McCusker thinks that n3 syntax is good:-

I like n3 (aka notation3, aka wiki wiki syntax notation3). It not only doesn't suck, it's good and rational. Kudos, that will work. I can support that without the twinge of horror that RDF in XML gives me.
- n3 syntax is good (Re: RDF Torture Test)

Edd Dumbill of XML.com has also noted that N3 may offer an advantage over XML RDF thanks to its "scribblability":-

It is often said that one of the main obstacles to the greater success of RDF over the last two years has been its syntax. [...] The W3C has a strong culture of discussion and development using IRC, which is line-based. This seems to have been a contributing factor in the development of "Notation 3" (N3), a line-based syntax for RDF. [...] As one of the obstacles to the deployment of widespread metadata is getting people to write it in the first place, it may be that a readily "scribblable" syntax can help.
- A New Old Angle on XML (XML.com), Edd Dumbill

Morbus Iff prefers N3 to XML/RDF (and is noted for his "code shui"):-

Just as RDF/XML is ugly as sin, there are much prettier implementations available (N3 and N-Triples) that make working with RDF easier.
- The Semantic Web: 1-2-3 (Stupid Berry Pickers Make Idiot Jam), Morbus Iff

On how N3 should be used:-

2001-06-01 03:55:12 <DanC_> [...] I see N3 as mostly a poor-man's RDF authoring tool. I don't expect to use it for interchange.

RDF Developer
SBP (© Sean B. Palmer).