Read more

I called it “A Rubyist’s instant grasp on semantic web“. I’m still working on it, but it would be nice to have some comments. I feel like it’s not as fun to work on something on our own, so that’s why I decided to share it at this early stage.

Ok I’m now gonna merge this blog to another plateform. Wish me luck!

Also, I created my Github account where I had my first encounter with, well, git. I come from the world of Subversion, and yes, it is definitely different. It has its own strength and I like the underlying simplicity behind the git philosophy, where we only deal with “snapshots” (which IS confusing when you are used to svn).

If I’m posting this article it’s mainly because I would like to get feedback form experienced Rubyist concerning the coding, the api, the github aspect, all of that.

The github page for the library is http://github.com/mikaa123/SparqlTransmission

I will probably talk about the library in more details in a few days, as the development goes on.

Then, I usually check what’s happening in my little Internet “microcosm”. What I came across this morning was a tweet from W3C. It was announcing a webcast called “Coffee with Browser“, that talks about Semantic web. Wow. W3C, Coffee, Semantic web, all in the same sentence? Well yea, it does make sense, but come on! Coffee! I was drinking coffee! Those guys are genius.

Ivan Herman at Coffee With Browser conference about Semantic Web

This webcast featured a presentation by Ivan Herman, the lead of the Semantic Web Activity at the World Wide Web Consortium. It was held in Sao Paulo, Brazil. It was an introduction on the different set of practices and standards that form the Semantic web. When I got on the webcast, he was talking about the Resource Description Framework, or RDF, one of the most basic layer. What’s interesting is to realize than at the end, it all comes down to RDF. If you want to open your data to the semantic web world, all you need to provide is a usable RDF dataset. Of course, on top of that, there are a large panel of other standards, because the semantic web isn’t about technologies, it’s not meant to be relying on a technology, it’s meant to rely on standards. Take RDF, it’s not a technology: it’s an abstract language that uses the graph theory to describe data. It is not an implementation. RDF/XML is an implementation.

From this webcast I’ve also learnt that companies like Oracle are very interested about semantic web, and that, if I understood correctly, could provide ways to store RDF and query it using SPARQL? That’d be very promising. It has also been said that Google is involved, and here’s a tip for all you SEO fanatics: supposedly, adding RDFa – which is only a small micro-format you can wrap your html data in –  to your pages increases your position on the search engine… supposedly.

What I loved was one example of an “unexpected” use of linked-data. It is called the Newspaper Club. The idea is to provide an actual newspaper for small neighborhood. With newspaper club you can create a newspaper for, let say, everything that happens within 3 blocks of your house. The newspaper is then printed, and you can give it to your neighbors. What’s fun and surprising, is that you won’t need to write anything in the newspaper: it’ll be created automatically. What happens is that it uses the data provided by the english government, which is huge, and – using the defined vocabularies – extracts facts about your neighbor, such as the newest grocery store, or what event is going on this week. Things like that.

There’s something I’d like to mention, though. Ivan Herman said, as a conclusion, that we still have a “long way to go” for the semantic web. I don’t believe this. I think it’s usable TODAY. Not only can you ALREADY (please forgive me for the capslock) use a HUGE amount of linked-data, but it’s EASY to publish your OWN! We have the standards, we have the technologies. Yes, it’s evolving, but I’m pretty sure you can already publish some RDF file that uses solid, trusted ontologies, and those RDF files will still be usable in a few years. Even easier: just add RDFa description to your html pages! It’s as simple as that. Seriously. You don’t need to re-build your web-site from scratch: you can just add description to your data, little by little.

So this post addresses all of you trying to understand ruby meta-programming. It’s not a tutorial, and I’m not going to explain how it works, since there are a lot of amazing, well-written resources that do it perfectly. One of my personal favorite is this one.

So you know how Ruby is a dynamic language. It lets you add code even after run-time. It also allows you to have instance-specific behavior. To clarify, take this example: you have teddy, an instance of the class Turtle, and his friend nick (just call that one neck – as in turtle neck), his friend. They are both Turtles. Yet teddy, and only teddy can fly. How would you normally do such a thing, without creating a new SuperTurtle class? Well, in Ruby, you can.

Keep in mind that in Ruby, almost everything is an instance, or an object, if you will. The Turtle class is an instance of Class, which is itself an instance of Object. A Turtle being an instance, it can have its own instance methods: Turtle.new. Sounds familiar? But the “new” method is common to all the “Class” objects, since it was defined in the Class class. Okay, what about we create some class method in Turtle? Turtle.number_of_turtles, which returns the number of turtles. If you are familiar with Ruby, creating a class method is no big deal, still, we are calling a method on an instance of Class, and Class doesn’t define such a method. Do you see it coming? We are defining instance-specific behavior again.

It is possible to do such a thing because of the mighty meta-classes. Every instance has its own meta-class that stores instance-specific definitions.

Because I’m someone visual, and I know you are too, here is a diagram I did that might help you. It’s UML-Like (I didn’t want to use UML for this one, since we’re not doing it with classes but with meta classes). The white, round rectangles represent meta-classes.

Ruby’s Classes, Meta-Classes and their relationships

I’m hungry. Aren’t you?

I have a Macbook as a laptop, and I love the look and feel of applications in OS X. Macruby’s goal is to allow Rubyist to develop mac applications that runs as smoothly as applications created using Objective-C and XCode. But my story of Macruby doesn’t end here. After a few clicks here and there, I came accross something that literally blew my mind. The name is Hotcocoa. It’s a library that ships with Macruby as a layer on top of it. Hotcocoa takes the Cocoa framework and its 30-letters-long method names, and adds simplicity and expressiveness: it makes a philosophy shift from Objective-C to Ruby.

Hotcocoa was built by Rich Kilmer, and he did a brilliant presentation of it during RubyConf 2008, in Orlando. I highly recommend you to watch the video recording of the conference. After seeing this, I instantly started to build a small program using Hotcocoa, but I couldn’t find documentation, and as simple as a library can be, with no documentation, it’s impossible to use. For this reason I subscribed to Macruby’s mailing-list and asked about Hotcocoa’s API doc.

To my biggest dismay, I was informed that the project was no longer maintained, and that it won’t likely be maintained again. Rich Kilmer doesn’t have the time to work on it and moreover, people told me that they were using Interface Builder (which works with Macruby) to create their GUIs. I think Interface Builder is great and yes, it is way easier than using any method involving code to build user interfaces, but I like to hack around when I’m using Ruby. I like to try things. I don’t want to get restrained by some sort of architecture, and sometimes, I don’t feel like having this high-level of abstraction, Interface Builder and XCode open for a basic interface.

That’s when I met up with Shoes. It is described as a tiny GUI for Ruby. It was created by a very famous person among the Ruby community, Why the lucky stiff, who is also the author of a great programming book on Ruby (that is free, by the way) Why’s poignant guide to ruby which is full of humour and comics stripes, a delight to read! Anyway, _why disappeared of the internet one year ago, and left a big void (if you are interested by this, you can check the “Whyday“. PLEASE WHY, COME BACK!) Still, to come back to the main subject of this article, Shoes is being taken a good care by the Ruby community.

I have been working on a program using the Shoes GUI and I’m pretty sure my next posts are going to be about it.

Here is how a sub-classed ClassLoader that loads classes from a file looks like in Java:

[cc lang="java" escaped="true" width="100%"]

public class CommandLoader extends ClassLoader {
private String classpath;

public CommandLoader(String cp) {
super(CommandLoader.class.getClassLoader());
classpath = cp;
}

public Class loadClass(String className) throws ClassNotFoundException {
return findClass(className);
}

public Class findClass(String className){

byte classByte[];
Class result = null;

try{
result = findSystemClass(className);
return result;
}catch(ClassNotFoundException e){
e.toString();
}

String classp = classpath+className+”.class”;
System.out.println(classp);
try {
classByte = loadClassData(classp);
result = defineClass(className, classByte ,0 ,classByte.length, null);
System.out.println(result.toString());
return result;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

private byte[] loadClassData(String className) throws IOException{

File f ;
f = new File(className);
int size = (int)f.length();
byte buff[] = new byte[size];
FileInputStream fis = new FileInputStream(f);
DataInputStream dis = new DataInputStream(fis);
dis.readFully(buff);
dis.close();
return buff;
}

public String getClassPath() {
return classpath;
}

public static void main(String[] args) {

}
}

[/cc]

Why is it so complicated? Java is not a dynamic language, although it offers way of making it dynamic, such as the ClassLoader. To actually invoke methods on the classes loaded from a file at run-time, you still need to use Java’s reflective API.

Just to compare, doing the exact same thing using a dynamic language such as Ruby needs only the following code:

[cc lang="ruby" escaped="true" width="100%"]
buff = String.new

File.open(“classtest”).each do |line|
buff += line
end

eval buff
t = eval “Test.new”

t.hey
[/cc]
In dynamic programming languages, it is possible to add code at run-time, and that code above loads a class and evaluates it.

The important line of the above is this one:
[cc lang="ruby" escaped="true" width="100%"]
t = eval “Test.new”
[/cc]

The eval method checks if the expression between quotes makes any sense during run-time, and if it’s the case, it executes it. Another good point for scripting languages.

Yes, but if you dig deeper, you will find that those html pages- the content – are most of the time generated dynamically. It is the case because thankfully, we don’t create a new html file each time we want to add content to our website., instead, we fill nice forms, click the submit button and voilà, the content is added to our website. The content is stored on a database, which is where your actual code will get the data to generate nice looking html pages.

If you think about it, on the above description I identified three things, lets call them layers. The html pages (what you see), your code (that generates the html pages) and the database. This decomposition goes by the name of Model-View-Controller (MVC). It is the most used architecture for a website today, because it makes maintenance easier. I’m saying all this because the web, today, use this model. It is so widely used that companies released their own MVC architecture to be used as a framework for the development of other web-applications. It is the case of a software company called 37signals, who created Ruby On Rails (version 3 came out a few weeks ago), one of my favorite MVC framework for the web (I love Ruby’s expressiveness.)

I don’t want to get to techie here, I hope I’m not losing your attention, because here is the actual interesting part. I can’t query (access) another website’s database. First because they won’t allow me (it’s way too risky), and second because I don’t know how the database is modeled. Yet, all the information is there, and it has meaning – it is stored as tuples in tables – , but it’s not accessible. This raises the question: do we need a new architecture to build an interoperable web? Well, the Web Semantic Workgroup at W3C don’t see it like that. For them, the semantic web has to be an add-on on today’s web. It has to work without the need to start everything from scratch. In other words, it won’t require to change every website’s architecture. Actually, it doesn’t even require to stop using a database. We can take today’s 3-tier architecture (your browser, the website’s server, and its database) and add a fourth tier.

This fourth tier is a division of the 2nd tier between a presentation tier and an application tier. The role of the presentation tier will be to generate a regular html view for requests coming form a browser, while generating RDF responses each time its being queried using SPARQL (which is the language, standardized once again by the W3C, to query “semantic databases” – RDF files). This would be an immediate answer to add semantics to any website, without redefining all the architecture and re-doing everything from scratch. In this model, we are still using a database as the 4th tier, and the RDF generated by the presentation layer only describes the ressource requested. It’s not a complete representation of the database. I don’t think a complete representation of the database would be good either, security-wise.

In order to view the fast growing of Linked Data, I created a little image showing the 2008, 2009 and the new 2010 graph. Those graph were taken from here, and are under the CC-BY-SA license, so you may use the following image too, as long as it stays under CC-BY-SA license.

“Linking Open Data cloud diagram, by Richard Cyganiak and Anja Jentzsch. http://lod-cloud.net/”

What’s interesting here is to see that the amount of dataset more than double each year, in fact, it’s an exponential growth. Also, the above doesn’t depict all the linked data, but only the largest datasets (those with more than 1000 triples). As a developer, you can already query this huge distributed database and start building your own semantic applications within that circle. I’m curious to see what the 2011 graph will be looking like. I couldn’t find the FOAF profiles dataset in the new graph, maybe is it because it doesn’t have enough triples? You can find literally any kind of information, for instance there’s a dataset that represents the “Pokedex“, a Pokemon classification.