Neno/Fhat: Semantic Network Programming Language and Virtual Machine Specification

Neno / Fhat : Semantic Network Programming Language and Virtual Machine Specification Marko A. Rodriguez (1) Ryan Chute (2) Digital Library Research & Prototyping Team Los Alamos National Laboratory - Research Library (1) [email_address] . gov (2) [email_address] . gov Acknowledgements: Herbert Van de Sompel (LANL) and Johan Bollen (LANL)

Supplemental material.
All referenced articles and more information is available at:
http://www.soe.ucsc.edu/~okram
(or just Google Marko A. Rodriguez)
http://neno.lanl.gov/

The take home points.
The Semantic Web is a highly-distributed, flexible modeling framework.
The Semantic Web is primarily descriptive in nature. The Semantic Web is used to describe web-pages, services, systems, etc.
Neno is an object-oriented language that was designed specifically for the Semantic Web.
Fhat is a virtual machine represented in the Semantic Web.
With Neno / Fhat the Semantic Web now has a procedural component. The Semantic Web now includes object methods, algorithms, and computing machines.
The Semantic Web can be made to behave like a highly-distributed, general-purpose computer. Not just an information repository.

Overview Introduction to semantic networks A quick Semantic Web tutorial A quick object-oriented/virtual machine tutorial Neno the language and Fhat the virtual machine Practical applications Conclusion

The various network types.
There is the undirected network of common knowledge.
For example, vertex i and vertex j are related.
Then there is the directed network of common knowledge.
For example, vertex i is related to vertex j , but j is not related to i .
Finally, there is the semantic network (or directed labeled network/multi-relational network).
For example, vertex i is related to vertex j by the semantic s , but j is not related to i by the semantic s .
i j i j i j s

Example undirected network. Herbert Marko Aric Ed Zhiwu Alberto Jen Johan Luda Stephan Whenzong

Example directed network. Muskrat Bear Fish Fox Meerkat Lion Human Wolf Deer Beetle Hyena

Example semantic network. SantaFe Marko NewMexico Ryan California UnitedStates LANL livesIn worksWith cityOf originallyFrom stateOf stateOf locatedIn hasLab Cells Atoms madeOf madeOf researches Oregon southOf hasResident Arnold governerOf northOf

The subject / predicate/object perspective.
A semantic network is sometimes called a triple list .
The first element of the triple is called the subject .
The second element of the triple is called the predicate .
The third element of the triple is called the object .
Reads like a very simple sentence.
<marko> <worksFor> <LANL>
<fluffy> <isA> <puppy>
<herbert> <isFrom> <Belgium>
<LAUR-07-3678> <cites> <LAUR-07-2885>
subject object predicate

What are the benefits of a semantic network model?
In an undirected and directed network you can only model a set of homogenous elements connected to one another by a set of homogenous relationships.
For example, a co-authorship network of researchers, a citation network of journals, a friendship network of humans, a route network of airports.
In a semantic network, you can mix different elements and different types of relationships into a single semantic network data structure.
For example, a scholarly network of researchers, journals, articles, institutions all related to one another by a various types of relationships (see MESUR).
In fact, with a semantic network, all models can be unified into a single data structure ( * hinting at the Semantic Web * ).
Note : a recent paper demonstrates that there is in fact no fundamental modeling gain by using a semantic network representation.
Rodriguez, M.A., “Mapping Semantic Networks to Undirected Networks”, LA-UR-07-5287, [submitted], August 2007.

What are the drawbacks of the semantic network?
There is little research into the analysis of semantic networks.
How do you rank vertices in a semantic network? The relationship “ isFriendsWith ” may be deemed more important than the relationship “ livesInSameCityAs ”?
While semantic networks make it possible to represent multi-relational models, it is difficult to use standard network analysis algorithms on such models. It is a more complex data structure.
However, more “intelligent” algorithms can take advantage of this extra information.
Note : Two recent articles present methods for porting many of the popular directed/undirected network analysis algorithms to the semantic network domain.
Rodriguez, M.A., “Grammar-Based Random Walkers in Semantic Networks”, LA-UR-06-7791, [submitted], November 2006.
Rodriguez, M.A., Watkins, J.H., “Grammar-Based Geodesics in Semantic Networks”, LA-UR-07-4042, [submitted], June 2007.

What is the Semantic Web?
The figurehead of the Semantic Web initiative, Tim Berners-Lee, describes the Semantic Web as
“ ... an extension of the current web in which information is given well-defined meaning, better enabling computers and people to work in cooperation. ”
Perhaps not the best definition. It implies a particular application space--namely the “web metadata and intelligent agents” space.
My definition is that the Semantic Web is
“ a highly-distributed, standardized semantic network data model--a URG (Uniform Resource Graph). It’s a uniform way of graphing resources. ”
Note : The more network perspective is presented in a recent article.
Rodriguez, M.A., Watkins, J.H., Bollen, J., Gershenson, C., “Using RDF to Model the Structure and Process of a System”, LA-UR-00-0000, 2007 International Conference on Complex Systems, October 2007.

What is a resource?
Resource = Anything.
Anything that can be identified.
The Uniform Resource Identifier (URI):
<scheme name> : <hierarchical part> [ ? <query> ] [ # <fragment> ]
http://www.lanl.gov
urn:uuid:550e8400-e29b-41d4-a716-446655440000
urn:issn:0892-3310
http://www.lanl.gov#MarkoRodriguez
prefix it to make it easier on the eyes -- lanl:MarkoRodriguez
The Semantic Web
“ first identify it, then relate it! ”

The technologies of the Semantic Web.
Resource Description Framework (RDF): The foundation technology of the Semantic Web. RDF is a highly-distributed, semantic network data model. In RDF, URIs and literals (e.g. ints, doubles, strings) are related to one another in triples.
<lanl:marko> <lanl:worksWith> <lanl:jhw>
<lanl:jhw> <lanl:wrote> <lanl:LAUR-07-2028>
<lanl:LAUR-07-2028> <lanl:hasTitle> “Web-Based Collective Decision Making Systems”^^<xsd:string>
RDF Schema (RDFS) and the Web Ontology Language (OWL): The ontology is to the Semantic Web as the schema is to the relational database.
“ Anything of rdf:type lanl:Human can lanl:drive anything of rdf:type lanl:Car .”
Triple-Store : The triple-store is to semantic networks what the relational database is to the data table.
a.k.a. semantic repository, graph database, RDF database.

RDF and RDFS. lanl:marko lanl:cookie lanl:Human lanl:Food lanl:isEating rdf:type rdf:type lanl:isEating rdfs:domain rdfs:range ontology instance RDF is not a syntax. It’s a data model. Various syntaxes exist to encode RDF including RDF/XML, N-TRIPLE, TRiX, N3, etc.

RDF, RDFS, and OWL. lanl:fluffy lanl:marko lanl:Pet lanl:Human lanl:hasOwner rdf:type rdf:type lanl:hasOwner rdfs:domain rdfs:range ontology instance _:0123 rdfs:subClassOf owl:onProperty “ 1” owl:maxCardinality lanl:bob lanl:hasOwner owl:Restriction rdf:type

The named graph.
Suppose you want to make statement about a set of triples (a subgraph)?
The named graph provides direct support for reification .
A triple is quad: t = <s,p,o,g>, where g is a “graph” URI.
Triples can now be grouped according to the g URI.
Statements can then be made about sub-graphs: provenance, trust, etc.
R-triple1 Herbert 2005 PaperA JournalB R-triple2 R-triple3 ARecord Herbert 2005 PaperA JournalB ARecord OLD STYLE NAMED GRAPH STYLE

The triple-store. SELECT ?a ?c WHERE { ?a type human ?a wrote ?b ?b type article ?c wrote ?b ?c type human ?a != ?c }
There are two primary ways to distribute information on the Semantic Web.
1.) publish RDF/XML document on a web server.
2.) expose a public interface to an RDF triple-store.
The triple store is to semantic networks what the relational database is to data tables.
Storing and querying triples in a triple store.
SPARQLUpdate query language.
like SQL, but for triple-stores.
INSERT ?a coauthor ?c WHERE { ?a type human ?a wrote ?b ?b type article ?c wrote ?b ?c type human ?a != ?c } DELETE ?s ?p ?o WHERE { ?s ?p ?o }

Triple-store vs. relational database. Triple-store Relational Database SQL Interface SPARQL Interface SELECT (?x4) WHERE { ?x1 dc:creator lanl:LAUR-06-2139. ?x1 lanl:hasFriend ?x2 . ?x2 lanl:worksFor ?x3 . ?x3 lanl:collaboratesWith ?x4 . ?x4 lanl:hasEmployee ?x1 . } SELECT collaboratesWithTable.ordId2 FROM personTable, authorTable, articleTable, friendTable, hasEmployeeTable, organizationTable, worksForTable, collaboratesWithTable WHERE personTable.id = authorTable.personId AND authorTable.articleId = "dc:creator LAUR-06-2139" AND personTable.id = friendTable.personId1 AND friendTable.personId2 = worksForTable.personId AND worksForTable.orgId = collaboratesWithTable.orgId2 AND collaboratesWithTable.ordId2 = personTable.id

A birds-eye view of the Semantic Web. www.domainC.com <rdf> </rdf> www.domainA.com www.domainB.com Triple-store Triple-store Web-server HTTP GET SELECT application INSERT 127.0.0.1 LinkedData

The best things about the Semantic Web.
Inherently distributed.
The U niform R esource I dentifier ( URI ) is the “atom” of the Semantic Web.
Great tools like the triple-store and ontology development environments.
A great way to model many types of systems.
Has an eclectic usage-base.
Being used for general-systems modeling.
Being used for knowledge-representation in the AI community.
Being used for metadata for digital-libraries.
Being used for knowledge-representation in the bio-sciences.
Being used for metadata in the Web community.

The worst things about the Semantic Web.
Not well received by the research and web-user community.
Its so general, that its hard to pin-down exactly what the Semantic Web is.
The colloquial understanding of the Semantic Web is that of web-metadata and intelligent agents.
Personally, the “Semantic Web” is a bad name.
Hasn’t delivered the “killer app”.
Complicated to deal with (dubbed “triple hell”).
Not quite a “web” yet. Organizational networks are not combined into a universal substrate. Disparate networks make up the Semantic Web.
The URI is not necessarily a physical address. It’s a conceptual address.
Difficult to “jump” between different public networks.
Still a download and process environment.
Not entirely true (note the Linked Data movement)
http://sites.wiwiss.fu-berlin.de/suhl/bizer/pub/LinkedDataTutorial/

What is object-oriented programming?
An software abstraction pattern.
A class is a abstract representation of a “legal” object.
A collection of classes is an A pplication P rogramming I nterface.
An object is a collection of “key/value” pairs (fields) and its methods (functions).
A collection of objects is a run-time environment.
Human Human colleague; Company job; quitJob(); colleague colleague colleague colleague new Human(); Class Objects Fields Methods

The Semantic Web is a hop, skip, and solar system away from object-oriented programming.
In RDFS/OWL, there is the concept of classes and properties.
For example, “a human can befriend another human”, “a human can have one and only one xsd:string name.”
We see a similar paradigm in object-oriented programming languages such as Java and C++. Classes have fields.
However, in Java and C++, we see something else. We see the method . Any class can have any number of methods associated with it. In general, a method is used to change the class’ fields (properties). The methods are the algorithms which evolve the system model .
java.lanl.Object Field Method owl:Thing rdf:Property ??? We will focus on Java from here on out due to its strong similarities with Neno/Fhat.

How does Java work?
Java source code is written in a human readable/writable syntax called the Java language.
Human.java
Java source code is compiled to a machine readable syntax called Java byte-code.
> javac Human.java Human.class
Java byte-code is read in by the Java virtual machine and executed.
> java Human

Example of some Java source code. public class Human { public String name; public int example(String a) { if(a.equals(“marko”)) { return 1; } else { return 2; } } } Field Method Class Human.java

Java byte-code.
100110010000011000101110100001101
010100001010011111110011010010101
100110010000011111101110100001000
000010011111011000101110100001101
100110011110010100010010001001111
000100100101001000101010111001010
…
..
.
Human.class

Virtual machine computing.
A virtual machine, in short, is a computing machine represented in software, not hardware.
Perhaps the most popular virtual machine is the Java virtual machine (JVM).
It is the role of the JVM to interpret the Java byte-code (at runtime) and translate those instructions to the instruction set of the hardware CPU (e.g. Intel chip).
Java source code Java byte-code Java Virtual Machine Native Machine Code

Example of a simple virtual machine. public class SimpleVM { HashMap<String,Object> variables; public void execute(File code) { FileStream stream = new FileStream(code); String inst = stream.nextLine(); while(inst != null) { if(inst.startsWith(“ADD”) // do add else if(inst.startsWith(“BRANCH”) // do branch else if(inst.startWith(“INIT_VAR”) // initialize variable … } } } INIT_VAR x ADD 1 2 x BRANCH x > 2 GOTO 100 INIT_VAR y SUB x y x … .. . VIRTUAL MACHINE CODE CODE.TXT

What are the benefits/drawbacks of virtual machine computing?
+ “Write once, run anywhere.” In Java, the Human.class file can be run on any JVM regardless of the underlying hardware (e.g. Intel, PowerPC, etc.)
- Code executes slower. Because compiled code is not native machine code, there is a run-time translation to native machine code. That run-time translation takes time.

The Semantic Web is a hop, skip, and galaxy away from a general-purpose computing platform.
The Semantic Web is descriptive, not procedural.
It describes a system, not the rules by which that systems evolves.
Note : This dichotomy is discussed in a recent article.
Rodriguez, M.A., Bollen, J., “Modeling Computations in a Semantic Network”, LA-UR-07-3678, [submitted], May 2007.

Take home points of Neno/Fhat.
Pronounced “ knee-know fat ”.
Introduces the concept of a method to the Semantic Web.
Any OWL class can have any number of methods associated with it.
Introduces the concept of an RDF virtual machine (RVM).
Executes class methods.
Semantic Web

What is Neno/Fhat?
Neno is a semantic network programming language.
Neno human source code compiles down to Fhat triple-code.
Fhat triple-code is represented as an RDF network.
Fhat triple-code is read by a Fhat RDF virtual machine (RVM).
A Fhat RVM is represented as an RDF network.
Thus, the Semantic Web is no longer just a data modeling environment, but a computing environment where algorithms and computing machine are represented in the semantic network substrate.
Note : The full specification of Neno/Fhat is in a recent article.
Rodriguez, M.A., “General-Purpose Computing on a Semantic Network Substrate”, LA-UR-07-2885, [submitted], April 2007.

From Neno to Fhat. Neno Human Source Code Fhat OWL API Fhat triple-code compiles to > nenofhat -o N-TRIPLE Human.neno instantiates to lanl:Human h = new lanl:Human(); triple-store/web-server boundary

Neno. owl:Thing lanl:Human { xsd:string hasName[1]; xsd:integer example(xsd:string a) { if(a == "marko"^^xsd:string) { return "1"^^xsd:integer; } else { return "2"^^xsd:integer; } } } Human.neno owl:DatatypeProperty neno:Method owl:Class

Some interesting constructs in Neno (part 1).
Multi-instance fields.
Set, set plus, set minus, set clear.
xsd:string name[1]; lanl:Human hasFriend[0..*]; xsd:date graduated[0..1]; this.name = “marko”^^xsd:string; this.hasFriend =+ lanl:johan; this.hasFriend =- lanl:johan; this.hasFriend =;

Some interesting constructs in Neno (part 2).
Inverse field referencing (dot-dot notation).
Inverse method invocation (dot-dot notation).
// returns the name of all // lanl:Humans that have this // as a friend. this..hasFriend.name; this..hasFriend.example(“7”^^xsd:int);

Fhat triple-code. owl:Thing demo:Human { xsd:integer example(xsd:string a) { if(a == "marko"^^xsd:string) { return "1"^^xsd:integer; } else { return "2"^^xsd:integer; } } } Instantiates to

Fhat RVM. PC (current instruction) Method variables LIFO Stack

The operand stack. x = 1 + (2 * 3)

The Fhat state and the Fhat process.
The Semantic Web is a data structure. It does not have the ability to compute itself in and of itself.
The Semantic Web represents the state of the Fhat RVM.
An external process evolves the state of the Fhat RVM.
It’s a while(!halt) loop with no state.

General system architecture. Neno source code Fhat triple-code Fhat RDF Virtual Machine Native Machine Code ?Other Virtual Machine? With Fhat, the state of the RVM is maintained in the triple-store. An external process evolves the state of the machine and thus, computes. Fhat RDF State Fhat RDF Process

General system architecture.

r-Fhat.
r-Fhat stands for “ reduced Fhat ”.
The virtual machine’s state is harvested from the triple-store and represented in main memory of the underlying hardware machine.
When the hardware representation has completed execution or is halted, it can be re-represented as RDF and inserted back into the triple-store.
Benefit? Significantly faster.
Triple-store Fhat Process Triple-store Fhat Process Triple-store Fhat Process SELECT/DELETE out Fhat state INSERT in Fhat state TIME Triple-store Fhat Process Execute.

Benefits and drawbacks of this computing model.
+ The World Wide Web provides the infrastructure to distribute human consumable information (e.g. web-pages, scholarly articles). The Semantic Web now provides an infrastructure to distribute machine consumable models (e.g. system models, algorithms, and computing machines.)
- Various levels of computing indirection using this model -- thus slower than the JVM model of computing and therefore, the machine-level model.
- Lots of read/writes for triple-store computing. Slow.
Hence r-Fhat.
+ Everything is represented in RDF. The data, the code, and the computing machines. A “pure URI” computing environment. No change of syntax.
+ Easy to distribute software and computing machines. Both Fhat triple-code and Fhat RVM instances can be represented in an RDF/XML file and HTTP “GETTED” or “SELECTED” out of a triple-store.
- “Triple bloat”. Everything is in RDF.
Or an RDF-wonderland.
+ A completely distributed computing environment with an address space of all URIs (…which is an infinite space).

More interesting aspects of the RVM model.
no distinction between main memory and the disk drive because everything is in the Semantic Web.
the Semantic Web is no longer a information gathering infrastructure, but a distributed information processing infrastructure (the process can move to the data, the data doesn't have to move to the process).
the RVM can be distributed in mid-process across physical machines. No state in the RVM process.
easy to save the evolution (i.e. history) of an RVM (its state is saved in RDF).
RDF programs and RVMs are “first-class" web-entities (e.g. RDF/XML).
maintains the “write once, run anywhere" paradigm of Java.
because the underlying data structure is a semantic network, languages built on this idea can have unique constructs not found in other languages (e.g. inverse field referencing, multi-instance fields, field querying, etc.).
there already exists an infrastructure to support the paradigm and thus, requires very little investment by the community (triple-stores, ontology modeling languages, query languages, etc.).
an RVM can be engineered at any level of complexity (move the complexity to the software implementing the RVM to ease machine architecture development and increase running time). E.g. r-Fhat.
language reflection at the API, software, and RVM level (everything is represented in RDF).
removes the stack of representation (triple-code can manipulate the RVM that is manipulating the triple-code).
the RVM is an object much like any other object in an object-oriented programming environment (the RVM can call methods on itself).
any object can have the property of an RVM and thus, any object can be its own processor (easy to thread objects).

Some Neno/Fhat computing models.
The Open Computing Model .
Supports the distribution of not only data, but processes and computing machines.
The SandBox Model .
The “SETI@Home” distributed computing model.
The process can move to the data, the data need not move to the process.
The Evolutionary Computing Model .
Pure URI computing environment supports completely reflective computing.
Esoteric computing.

The open computing model.
The World Wide Web allows for the distribution of information -- web pages and scholarly articles.The Neno/Fhat Semantic Web allows for the distribution of processes -- data sets (current Semantic Web), algorithms, and computing machines.
Open Data (note FreeBase http://www.freebase.com )
“ Numerous scientists have pointed out the irony that right at the historical moment when we have the technologies to permit worldwide availability and distributed process of scientific data, broadening collaboration and accelerating the pace and depth of discovery…..we are busy locking up that data and preventing the use of correspondingly advanced technologies on knowledge .” - Wikipedia
Open Process allows for the distribution of not only data sets but the algorithms that operate on those data sets. Representing everything in the same substrate allows for an easy commingling and distribution of these various computing components ( Open Computing ).

Open computing and Java vs. Neno.
In Java, code is written to a particular data model.
Data can have any number of formats
CSV, some XML format, relational database, binary, etc.
In Neno, code is written to a particular ontology, not a particular data model.
If data obeys that ontology, that Neno code will work for it.
There is a stronger sense of ontology reuse in the Semantic Web then in the relational database realm.
For example: FOAF, DOAP, DublinCore, ATOM, etc.
A stronger sense of application re-use for different data sets.

The sandbox model.
Servers can host a “Fhat-Farm”.
Fhat RVMs and triple-code can be pushed into the farm and get allocated cycles to work with the server’s data set.
The process moves to the data, the data doesn’t move to the process.
Server triple-store Fhat Farm INSERT/SELECT

Named graphed sandboxes.
A Fhat and its triple-code is allocated a named graph to execute its process.
Any Fhat can read from the entire triple-store, but can only write/delete to its allocated graph(s).
Computing model is protected against malicious or poorly written code.
Fhat Graph UUID:1 Fhat Graph UUID:2 Fhat Graph UUID:3

Link data and the sandbox model.
RDF network points to location of next “link in the network”.
Processes can move between servers and work with various local data sets for their global computation.
www.domainB.org Triple-store www.domainA.org Triple-store www.domainC.org Triple-store t=1 t=2 t=3 INSERT INSERT

The sandbox model and Java vs. Neno.
Java is “unsafe”.
Awkward to distribute . class files to a particular data server.
Publishing relational database schemas isn’t the norm.
Threads are not easily managed unless written to the server’s API.
Neno has no concept of the underlying machine (chip or drives). It is machine safe.
Easy to INSERT/SELECT machines/algorithms into and out of triple-stores.
One protocol (e.g. SPARQLUpdate) for all communication.

The evolutionary computing model. Everything is a URI. A Fhat RVM can get a pointer to itself and thus, process itself.

A birds-eye view of the Neno/Fhat Semantic Web. www.lanl.gov www.domainC.com www.mesur.org <rdf> </rdf> www.domainA.com www.domainB.com <rdf> </rdf> www.domainD.com Triple-store Triple-store Triple-store Triple-store Web-server Web-server application RVM Fhat Process Fhat Process Fhat Process Linked Data

Where is Neno/Fhat now?
Nenofhat compiler is written in Java 1.5+ using ANTLR 2.7.
Compiles Neno human source code to an OWL Fhat API.
Fhat RVM process is written in Lisp for the AllegroGraph triple-store.
Nearly supports r-Fhat.

Where does Neno/Fhat want to go?
Nenofhat compiler is written in Java 1.5+ using ANTLR 3.0.
Compiles Neno human source code to an OWL Fhat API.
Increase the functionality of the compiler.
Code optimization.
Debugging support.
NenoDoc capabilities.
NenoDoc is a publishable ontology (OWLDoc).
Fhat RVM process is written in Lisp for the AllegroGraph triple-store.
Completely support r-Fhat.
Support the SAIL interface for other triple-store providers.
Support web-based harvesting (non-triple-store computing).
?WebDav?
Develop a solid, core Neno API for developers.
Locate Semantic Web projects and work with them to implement some Neno-based software.
Work with the Linked Data people to realize powerful application scenarios.

Questions? Neno / Fhat is at http://neno.lanl.gov Many thanks to the L A N L Research Library for their support.

Neno/Fhat: Semantic Network Programming Language and Virtual Machine Specification

by Marko Rodriguez

Accessibility

Categories

Upload Details

Usage Rights

3 Embeds 10

Statistics

Neno/Fhat: Semantic Network Programming Language and Virtual Machine Specification Presentation Transcript

http://www.slideshare.net	7
http://codetopper.com	2
http://www.linkedin.com	1