The Semantic Web enables interoperability without prior communication. It does this by channeling communication through assertions of the truth of binary relations, where the relationship and the objects are identified using strings which anybody can create.
I'm not on the RDF Core WG or WebOnt WG, but I try to follow their work and participate when I have something to offer.
Writings on The RDF Model, Rearticulated and a start at Semantic Web Architecture. (Both are old but good.)
General writings on the identification problem . I want to turn this into a clear matrix of use cases and proposed solutions. My proposal for a practical and semantically-clear identification scheme is tag: URIs, still languishing with the IETF. More recent thoughts: uname proposal.
Recent: RDF Databases, replacing old work on Deductive Triple Stores Here I'm viewing the SemWeb more as a web of databases than a message-passing space.
The Blindfold Hypothesis: People can effectively use domain-specific formal languages (such as XML with their own tags) as if it were RDF, as long as they provide an appropriate definition of the semantics of their language (such as a blindfold grammar).
An n3 parser in lex/yacc
Trivial Syntaxes for the semantic web. How simple can they be? What are literals? (coming soon: What about anonymous nodes?)
I really need to document SWAN, which is somewhere between n3 and C.
Also: XML with Relational Semantics: Bridging the Gap between XML and RDF.
Two postponed starts: Open World for Distribution and Delegation , and Agent Blackboard Diagram .
The Services-Via-Databases Hypothesis: The two communication modes (message-passing and shared-memory-access) can each be used for all communication tasks, but shared-memory-access is better for larger and more complex systems (like the semantic web).
This approach can be fitted in at many levels. At one end of the spectrum, the whole app can be declarative knowledge. Somewhere in the middle, an agent can use SOAP and look like any other WS agent, while using declarative knowledge internally. At the other end, everything can be proceedural and message-passing.
Logics are essentially data-driven abstract algorithms. A logical formula is data which an inference engine can use to perform some operations on a database. Generally the operations are very simple but can combine in such complex ways that they appear "intelligent". If we use logics to express our knowledge about classes of objects (ontological information), computers can infer additional information and check for some kinds of errors.
I'm much more comfortable with Horn Logics and classic FOL than Description Logics (as in DAML), but I'm getting more flexible.
XSB work .
Blindfold C++ Toolkit, which in some versions is also DAML-diff. Should be migrated to use ACE.
some perl stuff, which has gotten messy. There are two kinds of RDF interfaces: triple-oriented and property-oriented. This did property-oriented rather well (perlishly), but then I threw in triple-oriented and it got too complicated. Should be merged with EricP's rdf/perl stuff.
A semantic web user interface: Bricklayer. mockup-1
I don't generally get this far up the stack, but sometimes I write about ideas.
Maintaining the Dependencies between Web Pages .
project management/to-do list/accomplishments
$Date: 2013-04-08 22:16:06 $