02-10-07
Distributed Computing
I believe the future of technology is in the area of distributed computing and P2P.
02-10-07
The Dawning of the Knowledge Age
As technology continues to increase in both its breadth and complexity, we may begin to consider new motivations for the advancement of science including mutual enlightenment.
02-05-07
Distributed Data Structures
I'm looking into using C# generics to make these Chord, Kademlia DHT's more reusable. Also looking into other distributed data structures like distributed lookup tables (DLT), and such. Basically, hoping to give application developers options in terms of data structures for this library.
02-05-07
KAON2, Pellet, Racer to C#
On the back burner is porting over these Java engines to .NET, though not sure whether they'll be engines or their own module types. Probably won't have these done for version 0.52.
01-29-07
OWL/C# mapping — towards semantic-based programming
Goal: convert OWL, DAML, et al, files into jars or assemblies that contain types that behave exactly as intended and at the same time are intuitive to use by programmers. The method being explored is to emit programmatic logic into accessors and type conversion operators. Plan B is to use a large number of interfaces. Ideally, the tools available to ontologists will be of use in creating powerful type libraries for semantic-based programmers.
OWL features from: http://www.w3.org/TR/owl-features
RDFS Features
Class (Thing, Nothing) — Thing extends System.Object, OWL-Based ontologies use this as a base type. Nothing is a sealed static class with no constructors, it may (I'll have to read more) have a static reference to a singleton instance.
rdfs:subClassOf — This maps to type inheritence. For multiple inheritence, the class is duplicated into equivalent types in the tree with type conversions between them and all involved types having the same URI in their metadata.
rdf:Property — This is a property {get, set} that is either a reference to an object instance, a type, a datatype or a List<> of one or more of those object types. Unlike programming, OWL can describe the properties independently of the class types they are in; it can talk about a property and place it into multiple class definitions and then optionally distinguish them from there.
rdfs:subPropertyOf — P1 is a subPropertyOf P2 allows us to say that whatever an object instance O should have for O.P1 is a subset of what it has for O.P2. This logic can be emitted into the accessor methods.
rdfs:domain, rdfs:range — A property can have a domain and range (global restriction to property being discussed on its own, outside of its use for a specific type). The domain is the set of types that can have this property either specifically or through inheritence. The range is the type of the property (or set of types (?) in OWL Full) that the property can have.
Individual — an instance of a type that has been constructed for use or received via transmission or from storage.
Equality and Inequality
equivalentClass — we can do a type conversion and should be able to roundtrip without loss.
equivalentProperty — for whatever reason, we have two property names that are the same. TypeA.propertyA has the same constraints as TypeA.propertyB or TypeB.propertyB. An example would be someType.hasIP and otherType.hasIPAddress
sameAs — two object instances are equal. We can programmatically accomplish by use of operator overloading or an Equals method, because they can't be the same object reference as they have one differing property, their InstanceURI.
differentFrom — two object instances are not equal. This might be useful if they have all the same properties except for InstanceURI.
Alldifferent — this is a notational convenience to apply differentFrom pairwise to a set.
distinctMembers — used with the above.
Property Characteristics
ObjectProperty — relates two object instances or an object to a list of objects.
DatatypeProperty — relates an object to a datatype (int, string, etc) or a list of datatypes.
inverseOf — if P1 inverseOf P2 then O1.P1 contains O2 implies O2.P2 contains O1 and vice versa. Whether property characteristics additionally place properties into the related type(s), should it not be otherwise declared, is unknown.
TransitiveProperty — if P3 is transitive, then O1.P3 contains O2 and O2.P3 contains O3, implies that O1.P3 also contains O3. An example would be a method List<Type> BaseTypes() that lists all the types that a given type decends from.
SymmetricProperty — if P4 is symmetric, then O1.P4 contains O2 implies that O2.P4 contains O1.
FunctionalProperty — the property is not a list.
InverseFunctionalProperty — the property uniquely identifies the object instance.
Property Restrictions
allValuesFrom — this is the the type that the property returns in its getter and that it expects in its setter, could possibly be a list of that type.
someValuesFrom — this means that at least one value in a list from or to this property must additionally meet a criteria of being a possibly more specific type. The example given is (roughly:)
{
{
set { ... }
AND we want to say that at least one of the elements in hasKeywords must be of type SemanticWebTopic which is taken to be an extension of Keyword. Options here include the creation of a new generic type ConstrainedList<T>, adding logic into the accessors, adding logic into the type conversions or other possiblities. This is important because some types can only be converted when meeting this instance-based criteria (what happens in the event conversion is not possible? null? exception?). We might say that an object of type Paper can be converted to type SemanticWebPaper iff one of its Keywords is convertible to type SemanticWebTopic.
Restricted Cardinality
minCardinality, maxCardinality, cardinality — these basically tell us if we're dealing with a list or an instance with respect to a property and any constraints on the number of members in that list.
OWL DL, OWL Full Vocabulary
oneOf — this is basically for creating an enumeration of object instances. For example, the type daysOfTheWeek could contains seven static references.
hasValue — similar to the someValuesFrom instance-based constraint (above), except that is a value-based constraint on a property. A type is definable by one or more specific properties having specified values (a property must have a specific value for a certain property for type conversion to succeed).
disjointWith — instances of a type are declared not to be of another type. This raises the point of negation-based types, e.g. NotSemanticWebPaper as something potentially utilizable in method signatures.
unionOf, complementOf, intersectionOf — these are ways to define instances of a type as being members of other types with logical constraints on the relationships between the types involved.
complex classes — this is basically where things get trickier, where a property can (? if I'm reading it correctly) have a set of ranges, possibly unrelated, which will take some work in a strongly-typed environment.
01-28-07
Facet-Based Serialization and Deserialization (serializable interfaces)
I'm working out how to send objects by facets (interfaces) to avoid having to send entire objects that may be large in rich ontologies when in a transmission context only a subset of those properties makes sense to send. There's really no "send TypeA as IAspect" built into today's serialization tools that I can see. I googled serializing interfaces and saw some Q&A's with responses basically arguing that it can't and/or shouldn't be done. This didn't jive with the spirit of rock & roll that is the field of modern computer science. So, brushing aside the standard objects coming with .NET for this sort of thing, you'll be able to with this library. Basically, the XML will resemble:
...
</yourType>
or (still weighing the semantics)
...
</IyourInterface>
The powers that be (©2007) decided that the Serializable attribute doesn't apply to interfaces so I'll make a SerializableInterface attribute for interfaces. I'm looking into how to generate compiler errors because the caveat is that every serializable interface must contain a From(interfaceBeingDefined i) method declaration so that your serializable types can create themselves or ammend themselves from the serializable interface that you programmed for or decided that your object should implement in transmitting a facet of itself. This could be also easily solved by having serializable interfaces decend from a base interface with the From method but this impairs code readability as yourType would contain the method 'void IyourInterface.From(BaseSerializableInterface i)' instead of 'From(IyourInterface i)'.
public interface IyourInterface
{
...
I'll implement it with some other protocols. Protocol modules will have a metadata attribute that they can do this, the default will be not. The strongest argument against this is that serialization is about fidelity and sending entire data structures but with serialization surrogates there's already flexibilty between data structures and data representing them. If anybody thinks one of the semantics "Type as Interface" or "Interface of Type" makes a lot more sense than the other feel free to contact me. Basically, the system will emit a type implementing IyourInterface's properties and pass an instance to your From method after creating an instance of yourType. Additionally (not shown above) you can create your own proxy class for IyourInterface and declare it via [SerializableInterface(typeof(yourProxyClass))] where yourProxyClass implements IyourInterface.
knowledge acquisition through accessors
In representing RDF/OWL in the strongly-typed and single-inheritence environment of C# and considering facet-based serialization (above), it occurs that code might want a property of an object that is unknown. The library will provide a static class called Acquisition that will delegate to other modules in this event (or you can write your own component for this), so you can program or emitted types can contain (something resembling) the following:
public static Hierarchy.of.classtypes.foo.Instance : Hierarchy.of.classtypes.Instance
{
// type conversion to equivalent type
public static implicit operator Hierarchy.alt.equivalentclass.Instance(Hierarchy.of.classtypes.foo.Instance i) { ... }
[URI("http://something.com#aproperty")]
public string aproperty
{
{
set
{
private string _aproperty = null;
01-28-07
Java vs .NET (2)
I was ready to write that Java was superior with regard to being able to unload class files or a runtime created type, but it turns out (according to what I read) that you can't. In C# you have to create a distinct AppDomain and unload the whole thing, and apparently in Java you have to create a custom classloader and unload the whole thing (Tomcat and JRun do this according to http://blog.taragana.com/index.php/archive/how-to-unload-java-class/). In C#, communication across AppDomains is slower than in a single one. I don't know if this is true for across classloaders or if that makes sense (across classloaders). I'll have to read into that more- I've never made a custom classloader in Java.
Reason being, ideally, type info for the Ontology modules would be fluid or semi-fluid not requiring a runtime type to be finalized or only alterable when rebooting the software (or unloading and reloading the ontology module). A case being the addition of an equivalent class requiring a new type conversion implicit operator for the existing class (SUMO.dll). Getting type info from these modules across application domains might slow down response time (cross-domain deserialization). Presently, Ontology modules are delegated to by use of their root namespace property (SUMO.) during the AppDomain type discovery process.
If anybody knows a way to create a type using TypeBuilder, use it for a time, and then ammend to it (or even recompose it) without unloading the AppDomain, please let me know. I'm thinking about partial classes, I'll have to experiment with emitting with the partial keyword (Update: no dice on that, doesn't make it into the IL. Now looking into PHX.Morph, Wicca.v2 and Mono.Cecil). I may have to find some bulliten board for .NET 4.0 wishlisting. I'm looking through the Mono code now about it. If you're interested in fast dynamic runtime typing for any reason, let me know and I'll email you any results I find.
01-28-07
Respect to the OWL-S process model
Sometimes you come across something and think 'hrm, why didn't I think of that' or 'that's a good idea, I'll use it' and sometimes you think 'this fundamentally changes the field and possibly theory of computing'. In my opinion, the OWL-S process model is the latter.
01-27-07
The Dark Tower Graphic Novel Series
Stephen King literature, graphic novel format. Who could ask for anything more?
http://www.marvel.com/darktower
01-27-07
The Semantic Web needs some buzz
I'm taking a cue from some TV commercials I remember.
This is the Internet on Web
<title>I'm another news story</title>
<description>Hello, I'm the news story that has appeared on your screen. Read this description to find out if you're interested in following the link. Maybe you are, maybe you aren't. Maybe this stock is in your portfolio, maybe it isn't. Maybe the stock symbol isn't in the article directly. That's why you're reading this description. Hopefully the journalist knows enough about auto-summarization and search trends to put the important keywords in (and the synonyms you use) before the auto-summarizer...</description>
<link>http://www.newssource.com/story</link>
This is the Internet on Semantic Web
<resource type="alert" content="html">
<message id="12" rank="important">Citrus Crop Weather Alert</message>
<title>Hurricane watch on Atlantic</title>
<link>http://www.yougotthisinformation.com/story</link>
<reason>Climate conditions predicted to affect domestic citrus crops.</reason>
<reasonlog via="10gic engine 2.3" traceid="31401">
<reference dataset="stockportfolio"/>
</reasonlog>
<via>p2p semantic search network #4</via>
<searcher>peersearch 1.7</searcher>
<related list="14"/>
</resource>
01-26-07
Project website redesign
I decided I didn't need javascript or flash since the target audience for the library is developers, who really don't need to be awed by some Flex2 widget that carousels information with reflective pngs. I decided that since the site was written in a technical subset of English so occult that a population less than a New Guinea tribe understands it, that I should go for a clean single page layout. Can I explain 'ontology' to anybody in plainspeak? Nope. Sarcasm aside, I'm really better at making things than explaining or documenting the things. However, once I make a first application on this library I'm heading right to rotating carousels with reflective png icons and eye candy. carousel?
01-26-07
Java vs .NET
I've seen some pretty wild "conversations" on the subject. When I get a CMS up with comments/forums, I'm really hoping for an objective look at the two for this sort of work, Semantic Web projects. I've seen (read) people literally get angry about operator overloading, static methods in interfaces and the such and I'm hoping to, instead, host a friendly conversation on the topic. Both have a lot of the same features, Eclipse is a great IDE (intellisense is a plus), and I'm aiming for .NET/Java interoperability as a goal. I read regularly on the Mono project and I'm excited that Sun recently made Java open source. I'm hoping to learn more about the substantial differences between the two (after the code is compiled). For example, if it turns out that Java has a more secure CAS system, I'd probably switch over immediately. This is unlikely though because stackwalking is stackwalking and permission sets are permission sets and computer resources are computer resources, so aside from a glaring hole in either VM's code, I'd have to guestimate that they're both secure and the differences are in notational conveniences to us developers. Java does have an advantage in that class files are already seperable. However, in a mobile code environment, they should travel in groups anyways as the idea of an assembly or jar is a group of interoperating classes, bundled together for 'some reason', with some accessing one another in a privileged manner because they were defined in the same package. Most of the differences that count for interoperability, in my opinion, are discussed at the IKVM and Grasshopper projects as they convert the bytecode between the VM's. Static methods in interfaces is a fairly important deal at that level, as it's no longer a programming construct.