HckLab - Working foR evolution

Domeo v2 working much faster on Firefox then Chrome

2012-01-14T00:59:00.006+01:00

Since a week now, I am deeply involved in developing the v.2 of the Domeo annotation tool. Domeo is a combination of GWT (Google Web Toolkit) and JavaScript. I've been mainly working on the infrastructure and, initially, as it is not much UI work, I was testing only on Chrome (16.0.912.75). Sadly, I've noticed several times that my code was not running fast enough and I started to study alternative ways of performing various tasks.

Then, out of curiosity, I ran the same tests on Firefox and surprise... what was running slow on Chrome was running almost without any latency in FF (6.0.2).

The test consists in 18 steps and each of them is adding the same amount of complexity. Looking at the above figure (milliseconds on the Y-axis) you will easily detect what I am talking about. The difference seems way too big.

Collections Ontology v.2... list of persons [1]

2011-09-26T15:34:00.010+02:00

Back in 2008 I've published a couple of posts explaining my need of creating an ontology for collections:

After some months of work with Silvio Peroni we are almost done with v.2 of Collections Ontology (CO) expressed in OWL2. Following is a simple example that illustrates some of the features of CO2. Before that here is how to set up the environment for testing the features yourself. First of all I would suggest you to install Protege 4.1 and to make sure to install the Pellet plugin for it.

With Protege up and running, I performed the import of the development version of the Collection Ontology v.2 with URL: http://collections-ontology.googlecode.com/svn/trunk/collections.owl.

Figure 1 - Import of the development version of the Collections Ontology (CO) with Protege

Figure 2 - Collections Ontology (CO) is imported

After that I've created a class person - note that I haven't reused classes such as foaf:Person to keep the example simple - and the instances in figure 3 in order to model a list of persons (you can download the file here).

Figure 3 - Collections Ontology (CO) example instances (ovals)

After triggering the reasoner, it is immediate to notice inferred properties (figure 4 in light yellow).

Figure 4 - Inferred types and properties for item instance itemOne. For instance itemOne has been defined as instance of item, the reasoner infers itemOne (i) is a list item (ii) is follwed by both itemTwo and itemThree (iii) is item of and is first item of persons.

Figure 5 - Explanation of itemOne type 'list item' obtaining by clicking the highlighted button

We can now proceed with some DL Queries.

Query 1
For instance we can ask for all the items that have item content (has item content) persons with name "Paolo Ciccarese":

item and 'has item content' some (person and (name value "Paolo Ciccarese"))

In the Protege tab named 'DL Query' we can enter the query above and, if we select on the right side the option 'Individuals' we are going to retrieve one item (itemOne):

Query 2
We can ask for all the lists where the first person is named 'Paolo Ciccarese' (answer 'persons'):

list and 'has first item' some (
item and 'has item content' some (person and (name value "Paolo Ciccarese"))
)

Query 3
Similarly we can ask more complex queries such as: find all the persons lists where the first item points to a person named 'Paolo Ciccarese' and the last item points to a person named 'Silvio Peroni' (answer 'persons'):

list and (
    'has first item' some (item and 'has item content' some
           (person and (name value "Paolo Ciccarese")))
    and
    'has last item' some (item and 'has item content' some
           (person and (name value "Silvio Peroni")))
)

Query 4
Another query can be: give me all the lists where the first person is named 'Paolo Ciccarese' and the second is 'Marco Ocana' (given the transitive nature of the property 'is followed by' the answer is 'persons'):

list and (
      'has first item' some (item and
            'has item content' some (person and (name value "Paolo Ciccarese"))
            and
            'is followed by' some (item and
                    ('has item content' some(person and(name value "Marco Ocana"))))
      )
)

Query 5
Returns all the lists containing a person named 'Paolo Ciccarese' (answer 'persons'):

list and 'has item' some (
item and 'has item content' some (person and (name value "Paolo Ciccarese"))
)

Query 6
Returns any list where a person named 'Paolo Ciccarese' is followed by a person named 'Silvio Peroni' (answer 'persons'):

list and (
    'has item' some (item and
            'has item content' some (person and (name value "Paolo Ciccarese"))
            and
            'is followed by' some (item and
                    ('has item content' some(person and(name value "Silvio Peroni"))))
      )
)

Query 7
Returns all the lists where a person named 'Silvio Peroni' is preceeded by a person named 'Paolo Ciccarese' (answer 'persons'):

list and (
    'has item' some (item and
            'has item content' some (person and (name value "Silvio Peroni"))
            and
            'is preceded by' some (item and
                    ('has item content' some(person and(name value "Paolo Ciccarese"))))
      )
)

SWAN, AlzSWAN, HyQue and Nanopublications

2011-09-22T20:46:00.002+02:00

While developing the SWAN ontology and the SWAN platform (see AlzSWAN for Alzheimer disease) there have always been two open issues: (i) the use of named graphs and (ii) the translation of the textual discourse elements (claims such as: Intramembranous Aβ could behave as chaperones of other membrane proteins) into a formal representation made of triples.

SWAN, HyQue and Nanopublications

View more presentations from Paolo Ciccarese

(i) The use of named graphs is a useful way for wrapping some content and specifying its provenance. Basically the idea is to create an 'onion layers' model where each layer has its own provenance. At the time - back in 2006 - I have been investigating the usage of named graphs - and TriX - for representing SWAN content. However, we decided not to implement such approach because the technological uncertainty in that uncharted territory - of developing an application like SWAN - was already high enough, named graphs usage was not homogeneous across the community and their serialization was not standardized. This meant introducing de-facto reification for some of the SWAN relationships in order to be able to attach the appropriate provenance. As Graphs are the topic of one of the task forces of the RDF Working Group for updating the 2004 RDF Recommendations, I was starting to think of resuming the old plans.

(ii) The translation of the textual discourse elements into a formal representation made of triples is, for instance, possible through the HyBrow (now HyQue) approach. Translating narrative into triples is not easy job though. Many already found the SWAN manual creation process of narrative claims very labor intensive. In fact, the SWAN curators have been usually rephrasing each claims/hypothesis to make them simple and self contained (including the minimum necessary context). Translation into triples requires, even more, starting from neat hypothesis and claims. And these are not always that easy to obtain.

These two SWAN-related issues have been in my thoughts since a while when the Nanopublication [1] concept came out.

A Nanopublication is a "set of annotations that refers to the same statement and contains a minumum set of (community) agreed-upon annotations.

The concept itself is simple and in the above linked slideshow you can find a first attempt based on real SWAN data. With respect to the paper, the concept of 'statement' (triple) has to be updated to 'statements' (triples) as one single statement is not always enough to satisfy needs of real use cases.

~~Statement~~ --> statements

Starting from the above example, we are now trying to formalize a bit better what a Nanopublication architecture would look like... it is work in progress, but if you look at the slides you will get the drift.

[1] Paul Groth, Andrew Gibson, Jan Velterop. The anatomy of a nanopublication. Information Services and Use (2010). Volume: 30, Issue: 1, Publisher: IOS Press, Pages: 51-56 (on Mendeley)

UIBinder, CssResource and CSS (GWT)

2011-09-21T22:04:00.002+02:00

Few month ago I blogged about ClientBundle, UIBinder and CSS (GWT). I just realized that an important use case was missing. And here it is.

4) Using CssResource for CSS expressed in the UIBinder. When creating a UI with the UIBinder it might happen to include some CSS rules in the ui.xml file.

<ui:UiBinder
  xmlns:ui='urn:ui:com.google.gwt.uibinder'
  xmlns:g='urn:import:com.google.gwt.user.client.ui'>

    <ui:style>
       .outer {
          width: 100%;
       }
    </ui:style>
    <g:SimplePanel ui:field='sideBar'>
    </g:SimplePanel>
</ui:UiBinder>

It is possible to refer to those CSS rules from the GWT code. For doing so we have to declare a 'type' for ui:style:

<ui:UiBinder
  xmlns:ui='urn:ui:com.google.gwt.uibinder'
  xmlns:g='urn:import:com.google.gwt.user.client.ui'>

    <ui:style type='org.example.Example.ExStyle'>
       .outer {
          width: 100%;
       }
    </ui:style>
   
    <g:SimplePanel ui:field='sideBar'>
    </g:SimplePanel>
</ui:UiBinder>

Now, in the class org.example.Example, we can reference the CSS rules and use them:

public class Example extends Composite {

    interface Binder extends UiBinder { }    
    private static final Binder binder = GWT.create(Binder.class);
   
    @UiField SimplePanel sideBar;
    @UiField ExStyle style;

    interface ExStyle extends CssResource {
        String outer();
    }

    public Example() {
        initWidget(binder.createAndBindUi(this)); 
        sideBar.setStyleName(style.outer()); 
    }
   ...

Grails 1.3.7, Spring Security and OpenID... with exception

2011-09-14T20:29:00.003+02:00

Here is the list of steps I performed to set up OpenID authentication with Spring Security:

1) Create Project with Grails 1.3.7

grails create-project UserManagement

The file application.properties will look something like this:

app.grails.version=1.3.7
app.name=UsersManagement
app.servlet.version=2.4
app.version=0.1
plugins.hibernate=1.3.7
plugins.tomcat=1.3.7

2) Installing the Spring Security plugin (website and documentation)

grails install-plugin spring-security-core

The file application.properties will now look something like this:

app.grails.version=1.3.7
app.name=UsersManagement
app.servlet.version=2.4
app.version=0.1
plugins.hibernate=1.3.7
plugins.spring-security-core=1.2.1
plugins.tomcat=1.3.7

3) Creating Controller and template classes

grails s2-quickstart org.commonsemantics.scigrails.module.users.security User Role

You will notice the following new files

controllers/LoginController.groovy
controllers/LogoutController.groovy
domain/org.commonsemantics.scigrails.module.users.security.User.groovy
domain/org.commonsemantics.scigrails.module.users.security.Role.groovy
domain/org.commonsemantics.scigrails.module.users.security.UserRole.groovy
views/login/auth.gsp
views/login/denied.gsp

The Config.groovy will be updated with the following lines:

grails.plugins.springsecurity.userLookup.userDomainClassName =
      'org.commonsemantics.scigrails.module.users.security.User'
grails.plugins.springsecurity.userLookup.authorityJoinClassName = 
      'org.commonsemantics.scigrails.module.users.security.UserRole'
grails.plugins.springsecurity.authority.className = 
      'org.commonsemantics.scigrails.module.users.security.Role'

If you are going to change the package of the above classes, just remember to update the above properties.

4) Move controllers to the desired package - org.commonsemantics.scigrails.module.users.security

5) Install the OpenID module (website and documentation)

grails install-plugin spring-security-openid

The file application.properties will now look something like this:

app.grails.version=1.3.7
app.name=UsersManagement
app.servlet.version=2.4
app.version=0.1
plugins.hibernate=1.3.7
plugins.spring-security-core=1.2.1
plugins.spring-security-openid=1.0.3
plugins.tomcat=1.3.7

6) Creates OpenId Controller and templates for it.

grails s2-init-openid

This script adds the following files:

controllers/OpenIdController.groovy
views/openId/auth.gsp
views/openId/createAccount.gsp
views/openId/linkAccount.gsp

7) Move OpenIdController to the desired package - org.commonsemantics.scigrails.module.users.security

8) Add support for the remember-me checkbox

grails s2-create-persistent-token 
     org.commonsemantics.scigrails.module.users.security.PersistentLogin

It adds the file:

domain/org.commonsemantics.scigrails.module.users.security.PersistentLogin.groovy

The Config.groovy is updated with the following lines:

grails.plugins.springsecurity.rememberMe.persistent = true
grails.plugins.springsecurity.rememberMe.persistentToken.domainClassName =
     'org.commonsemantics.scigrails.module.users.security.PersistentLogin'

Once again, if you are going to change the package of the above classe, just remember to update the correspontend property.

9) Creating the OpenID domain class

grails s2-create-openid 
     org.commonsemantics.scigrails.module.users.security.OpenID

The script creates on file:

domain/org.commonsemantics.scigrails.module.users.security.OpenID.groovy

The Config.groovy is updated with the following line:

grails.plugins.springsecurity.openid.domainClass =       
     'org.commonsemantics.scigrails.module.users.security.OpenID'

Once again, if you are going to change the package of the above classe, just remember to update the correspontend property.

10) Adding OpenIDs to the User domain class

The following line of code has to be added to the existing User.groovy class:

static hasMany = [openIds: OpenID]

11) Creating some test users

As suggested by the documentation we can now create some test users by editing the Bootstrap.groovy file as follows

import org.commonsemantics.scigrails.module.users.security.Role
import org.commonsemantics.scigrails.module.users.security.User
import org.commonsemantics.scigrails.module.users.security.UserRole

class BootStrap {

    def springSecurityService

    def init = { servletContext -> 

        String password = springSecurityService.encodePassword('password')
        
        def roleAdmin = new Role(authority: 'ROLE_ADMIN').save() 
        def roleUser = new Role(authority: 'ROLE_USER').save()

        def user = new User(username: 'user', 
            password: password, enabled: true).save() 
        def admin = new User(username: 'admin', 
            password: password, enabled: true).save()

        UserRole.create user, roleUser 
        UserRole.create admin, roleUser 
        UserRole.create admin, roleAdmin, true 
    } 
}

12) Redirect the login requests

It is now necessary to direct the authentication calls to the new Controller that manages also the OpenIDs. We can add to the UrlMappings.groovy file the following:

"/login/auth" {
         controller = 'openId'
         action = 'auth'
      }
      "/login/openIdCreateAccount" {
         controller = 'openId'
         action = 'createAccount'
      }

13) Running Grails and testing

grails run-app

Welcome to Grails 1.3.7 - http://grails.org/
Licensed under Apache Standard License 2.0
...
...
Configuring Spring Security ...
Configuring Spring Security OpenID ...
Server running. Browse to http://localhost:8080/UsersManagement

When accessing the page you should see something like this:

I will try it yourself but the authentication did not work for me right away. I logged in with my Google OpenID and I got sent to the screen for creating an account.

I then selected the 'link this OpenID' option.

After introducing the testing credential 'user' and 'password' I got a 'user not found' back.

14) Turning on the logging

First thing I wanted to see if there were any weird things happening by turning on the logging in the Config.groovy file:

debug 'org.springframework.security'

No exceptions emerged when repeating the process.

15) Making sure the User is stored in the DB

We can inspect the default HSQLDB by adding at the end of Bootstrap.groovy init the following:

org.hsqldb.util.DatabaseManager.main()'

this will open the in memory database inspector. Just remember that if you close the inspector that will also shutdown your Grails app. Read more about the inspector here and remember to take out that line once the debugging is done..

The users resulted stored in the database.

16) Making sure the encoding process works correctly

After editing the Bootstrap.groovy file with:

String password = springSecurityService.encodePassword('password')
println 'a ' + password
def admin = new User(username: 'admin', password: password, 
     enabled: true).save(failOnError: true)
println 'b ' + User.findByUsername('admin').password

and a restart, I obtained:

a 5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8
b 113459eb7bb31bddee85ade5230d6ad5d8b2fb52879e00a84ff6ae1067a210d3

It is clear that the login process is not performing correctly. After investigating I found out that the User domain class includes the methods:

def beforeInsert() {
          encodePassword()
     }

     def beforeUpdate() {
          if (isDirty('password')) {
                encodePassword()
          }
     }

17) Updating the Bootstrap.groovy file

As the User domain class is already performing the encoding, we have to edit the Bootstrap.groovy file line:

String password = springSecurityService.encodePassword('password')

Into

String password = 'password'

And now the login process works for me. We can now remove org.hsqldb.util.DatabaseManager.main() from the end of the Bootstrap.groovy and maybe comment out the logging (see point #14).

18) Remove the unused views and controllers?

It is not possible to remove any of the generated controllers. As far as I know the only file that can be removed is

views/login/auth.gsp

as the new auth.gsp file provided by the OpenID plugin is now in use (see point #12).

You can check out the code as follows:

svn checkout 
     https://common-semantics.googlecode.com/svn/tags/UsersManagement20110914  
     UsersManagement

Resources
OpenID website
Spring Security Plugin for Grails website
OpenID Plugin for Spring Security website

UIMA, Clerezza, AO and Linked Open Data [1]

2011-08-30T02:17:00.002+02:00

More than a year ago I started to work on the integration of text mining services with DOMEO, the tool I am building. In DOMEO we try to focus, as much as possible, on annotations that refers to entities defined in controlled vocabularies, ontologies or knowledge bases. In other words entities identified by URIs. Almost naturally, after writing a few connectors to existing text mining services, we realized how nice would have been to have a common way of exposing such services.

After some investigations, I found Apache Clerezza a service platform based on OSGi (Open Services Gateway initiative) which provides a set of functionality for management of semantically linked data accessible through RESTful Web Services and in a secured way. As I am familiar with the OSGi technology, I contacted the responsible for the UIMA integration - Tommaso Teofili - right away and we started to exchange ideas. After writing to the Clerezza mailing list, I decided to write and contribute some code able to transform UIMA results into Annotation Ontology (AO) RDF format.

Working with Antony Scerry (Elsevier) months ago, I learned right away that the hard part was not the code itself but the fact that the UIMA types are extremely flexible. Therefore, even if most existing NLP tools are not returning URIs, when text mining tools do return URIs it is not trivial to capture the URI of the recognized entity. That info can be encoded in whatever way the service developers decide to. That can be a problem when trying to integrate multiple text mining service under a common interface.

As I did not want to propose something too complicated, Tommaso and I convened that adopting a little convention could make our life easier. After a few discussions, Tommaso introduced a couple of basic entities: ClerezzaBaseAnnotation and ClerezzaBaseEntity. These are both implementing the property 'uri' and ClerezzaBaseEntity is also implementing the property 'label'. When creating new type system descriptors, in order to adopt the proposed convention, it is simply necessary to extend these two types and used them appropriately. As a result, through a patch I wrote, it is now possible, for instance, to map the results to the Annotation Ontology (AO) RDF format without any effort and, therefore, to display your results on the analyzed document through DOMEO.

Thanks to Tommaso, my patch has been integrated in the Clerezza code today. The documentation will be made available soon as well as other code that will allow to easily set up web services for publishing UIMA algorithm.

DOMEO: Linking science and semantics with Annotation Ontology (AO) [1]

2011-05-26T18:56:00.002+02:00

In the last few months I've been focusing on the development of the SWAN Annotation Tool (recently renamed DOMEO)*. DOMEO (Document Metadata Exchange Organizer), is an extensible web component enabling users to visually and efficiently create and share ontology-based stand-off annotation metadata on HTML or XML document targets, using the Annotation Ontology RDF model. The tool supports manual, fully automated, and semi-automated annotation with complete provenance records, as well as personal or community annotation with access authorization and control. DOMEO is one of the pieces of a bigger architecture that we internally call Annotation Framework.

The DOMEO interface
The idea itself is pretty simple, DOMEO is basically a little browser inside the browser. It allows the user to type a URL, open the correspondent document and annotate it. It is also possible to pass a URL as a parameter so that the tool opens with the page you want annotate already in the content frame. This option is particularly helpful when integrating the tool with other applications or other sections of the Annotation Framework.

Figure 1: A screenshot of DOMEO. You can notice the address bar where you see the URL of the document displayed below. The document displays the same way it would appear when opened in a new browser window.

The annotation can be performed manually by the user or automatically by text mining or entity recognition services. The two features are available through the two buttons in the DOMEO toolbar and labeled respectively 'Annotate' and 'Text Mining'. When the option 'Text Mining' is selected, the tool lists all the available text mining or entity recognition services. The user can then decide which one or which ones to run on the loaded document.

The button 'save' is saving the produced annotation. DOMEO supports a complex versioning system that basically saves items only when necessary, keeps track of the different versions and for each of them records the full provenance data. I will probably explain the versioning and the provenance models in another post.

* The development of DOMEO is managed and carried out by Dr. Paolo Ciccarese. DOMEO is a product of the MIND Informatics group - Mass General Hospital. The tool is developed in parallel with the Annotation Ontology (AO)

HTML5: The new 'semantic elements'

2011-03-03T17:31:00.003+01:00

One of the news in HTML5 consists in the so called 'semantic elements'. The goal of these elements is provide better way for web authors to define the parts of a document and, potentially, to improve accessibility (i.e. screen readers). Some of these elements are: section, nav, article, aside, hgroup, header, and footer.

Let's say I want to create the main page of a blog. My page is going to have a header and probably a footer. If you look at web pages source code, you will notice that these two elements are present in almost every page in many different variants. The blog you are reading already uses <header> and <footer>.

The elements <header> and <footer> can be used not only for defining the structure of the main page but also for defining headers and footers of sections, articles and asides.

If you look at the structure of the blog you are reading, this is pretty much similar to the one depicted in the above figure. The 'nav' areas is correspondent to the 'Blog Archive' and the 'aside' area is collecting my picture, 'label' and 'links'. Using these new elements - together with the new features brought by CSS3 - is certainly a way to avoid the well known 'Div Mania'.

Once we have a <header>, it is possible to use the element <hgroup>: it represents the heading of a section. The element is used to group a set of h1–h6 elements when the heading has multiple levels, such as subheadings, alternative titles, or taglines. Also, in the specs, given the following example, it is stated that the point is to mask the h2 element (which acts as a secondary title) from the outline algorithm.

<hgroup>
  <h1>The Coolest Application</h1>
  <h2>Alpha Release</h2>
</hgroup>

I have to admit, it seems a bit rigid and I feel my code will end up with one element more than usual. I have to force myself in not using <div> or <span> or <p> for things that look more like a subtitle and do something like:

<header>
  <hgroup>
    <h1>The Coolest Application</h1>
    <h2>Alpha Release</h2>
  </hgroup>
  <p>Description...</p>
</header>

One thought, the new elements seems still structural - with different level of granularity - and not semantic to me. Maybe structure can be seen as a kind of semantic, but I don't think the name is a good idea as it intersect with the pool of the technologies of the Semantic Web. In other words, saying a chunk of the document is a section does not help machine understanding of the content - besides that it knows where it starts and where it ends - , but if I say the section is a 'http://rdfs.org/sioc/types#BlogPost' we are starting to attach meaning we can leverage. And we can certainly do that with RDFa for example.

SWAN Annotation Tool: what is new in build 7

2011-02-28T03:09:00.001+01:00

Here is a list of some of the new features that I will deploy probably this week.

SWAN Annotation Tool: What is new in Build 7 from Paolo Ciccarese on Vimeo.

The development of the SWAN Annotation Tool is managed and carried out by Dr. Paolo Ciccarese. The fist build of the SWAN Annotation Tool has been developed by Dr. Paolo Ciccarese and Marco Ocana. The SWAN Annotation Tool is a product of the MIND Informatics group - Mass General Hospital - directed by Tim Clark.

ClientBundle, UIBinder and CSS (GWT)

2011-02-27T01:13:00.001+01:00

In a previous post I was discussing all the possible ways for using image resources with GWT. Another thing you might want to do is dealing with CSS.

1) Standard use of CSS. While using GWT you can certainly use the CSS how you would use them for any other application, simply declaring CSS classes in a *.css file and importing it in the webpage of interest. With GWT widgets you will then simply set the style name as follows:

widget.setStyleName("cssClassName");

This approach works, however, if the CSS declaration is missing no exceptions are raised. Also, if you use multiple CSS files as I do, it is always annoying to find the declarations when you need to.

2) Using the UIBinder. If you are already using UIBinder, the easiest way to include CSS declarations is to add them to the binder. It is easy and it is safe as the Eclipse plugin is helping you out in finding missing declarations. I always use Eclipse but if you don't I am assuming you'll still find the problems at compile time.

<ui:UiBinder
  xmlns:ui='urn:ui:com.google.gwt.uibinder'
  xmlns:g='urn:import:com.google.gwt.user.client.ui'>

    <ui:style>
       .outer {
          width: 100%;
       }
    </ui:style>

    <g:VerticalPanel styleName='{style.outer}'>
    </g:VerticalPanel>
</ui:UiBinder>

The downside of this approach is redundancy. Sometimes I want to use CSS declarations multiple times and, with this approach, I have to repeat them for each single Binder.

3) Using CssResource. Another alternative consists in doing something similar to what you can do for icons with ImageResource. First I declare the set of declarations of the stylesheet in a file that I name Commons.css:

.smallIcon {
    height: 16px;
    width: 16px;
}

Then, linking the CSS file, I declare the use of the stylesheet as a resource for the application:

public class Example implements EntryPoint {

  public interface Resources extends ClientBundle
  {
     public static final Resources INSTANCE =  GWT.create(Resources.class);
 
     public interface Resources extends ClientBundle { 
        @Source("org/example/application/client/Commons.css")
        CommonsCss commonsCss();
     }
     
     ...
  }
  
}

Now, where the dots in the above snippet are, I can declare the stylesheet declarations I want to expose to the application:

public interface CommonsCss extends CssResource {
     String smallIcon();
}

As the CSS class is named as the method everything works fine. However, sometimes you might want to change the name of the method. Using Java annotations you address that issue as well:

public interface CommonsCss extends CssResource {
     @ClassName("smallIcon")
     String smallIconClass();
}

Now, we can write something like:

Resources resources = Resources.INSTANCE.factory().create();
Image img = new Image();
img.setStyleName(resource.commonsCss.smallIcon());
...

This approach allows you to collect in one single place CSS declarations you need to use in multiple packages in your application. Also you can leverage a good amount of validation in your Java code. You might argue the process can be a bit tedious but I can assure you, for a big GWT application, it can help you saving lots of time later on especially when refactoring the code.

There are other interesting things to know about the ClientBundles, but for now I'll stop here.

Dublin Core and PRISM

2011-02-26T17:41:00.001+01:00

As I was saying in one of my previous posts, distinguishing the different kinds of contributions is not trivial. However, sometimes is necessary. And this is probably the case of publishers that want to keep track of the exact role of the different contributors to a resource.

This is the case of PRISM (Publishing Requirements for Industry Standard Metadata), a metadata vocabulary for managing, post-processing, multi-purposing and aggregating publishing content for magazine and journal publishing. PRISM allows to distinguish between different creators roles: writer, editor, composer, speaker, photographer... you can find the full list in the The PRISM Controlled Vocabulary Namespace. PRISM is also using parts of Dublin Core Element Set and Dublin Core Terms, the subset of terms is listed in the document named The PRISM Subset of the Dublin Core Namespace.

The combination of DC and PRISM, for instance for a book, will become in XML something like:

<dc:creator prism:role=”writer”>John Doe</dc:creator> 
<dc:creator prism:role=”editor”>Paolo Ciccarese</dc:creator>
<dc:creator prism:role=”graphicDesigner”>Micheal Doe</dc:creator>

In RDF, according to the specifications (paragraph 3.5.2 of the PRISM Subset of the Dublin Core Namespaces: Version 2.1), this would look like:

<dc:creator rdf:resource=”contributorrole.xml#writer”>
     John Doe
</dc:creator>
<dc:creator rdf:resource=”contributorrole.xml#editor”>
     Paolo Ciccarese
</dc:creator>
<dc:creator rdf:resource=”contributorrole.xml#graphicDesigner”>
     Micheal Doe
</dc:creator>

However, this is not valid RDF for a couple of reasons that you can find yourself through the RDF Validator Service. Dublin Core Element Sets properties used by PRISM and by the PRISM aggregator message are: creator, contributor, description, format (PRISM records restrict values of the dc:format element to those in list of Internet Media Types [MIME]), identifier (for instance DOI), publisher, subject, title, type. Other properties are listed but not as items of the PAM format: language, relation, source.

For instance, this is how PRISM can deal with identifiers in RDF:

<dc:identifier>10.1030/03054</dc:identifier>
<prism:doi>http://dx.doi.org/10.1030/03054</prism:doi>
<prism:url rdf:resource=”http://dx.doi.org/10.1030/03054”/>

Basically, besides the usage of dc:identifier, PRISM is using the properties prism:doi - which is declaring more explicitly than dc:creator what the identifier is - and prism:url. Strangely enough, the property prism:doi is actually taking as value the DOI proxy URL and not the DOI string. Therefore, I see prism:doi and prism:url as redundant properties. You can find some more details on this old blog post by Tony Hammond.

Moreover, PRISM PAM is making use also of the Dublin Core Terms dct:hasPart and dct:isPartOf for detecting for instance images that are part of a document:

<dcterms:hasPart rdf:resource= ”http://www.myexamples.com/ExamplePhoto.jpg”/>

AO: Annotating with one or multiple statements (triples)

2011-02-24T20:17:00.003+01:00

A few days ago I had a phone discussion with some collaegues (Tudor Groza, Vit Novacek and Cartic Ramakrishnan) on how to use Annotation Ontology (AO) for attaching something more complex than a single term (identified by a URI) to a document or document fragment. To make it clear I am giving here an idea on how something like that can be already done in AO.

Let's say I am performing some text-mining on some textual content. It is possible that I don't want simply to associate a term to a span of text but I want to do something more elaborate. For example I want to say, analyzing this span of text I obtain the triple GeneG encodes ProteinP. How can I do that in AO? For instance I can use a Named Graph and I can say something like in the following picture:

Figure 1: The dashed ovals are instances of annotation items. Selectors and other details of the actual annotation have been omitted.

As you can see we have annotated also the atomic components of my triple. In doing this, while analyzing the assertions belonging to a specific domain I can always trace back to the original text. Also, using a graph as object of my annotation I am going in the direction of the Nanopublication format, however this will be topic for a future post.

Given this, you can imagine you can attach the proper provenance to the annotation. If you are a text miner, you might be interested in attaching what software or computational workflow generated such annotation and with what confidence.

You might have noticed the usage of the namespace tm that stand for Text Mining. It is a set of properties I am working on for extending AO to better represent text mining results.

Principle: Traceability [2] - Provenance and Doublin Core

2011-02-24T01:04:00.019+01:00

For people working with Semantic Web technologies, for a long time, provenance has been called Dublin Core Metadata Element Set, a vocabulary of fifteen properties for use in resource description (as they currently state in the webpage). Let's take, for instance, the following property:

'creator': an entity primarily responsible for making the content of the resource. Examples of a Creator include a person, an organization, or a service. Typically the name of the Creator should be used to indicate the entity.

You can find the guidelines for the usage of the creator property here. If we consider the RDF format (important for providing a syntactical framework) we can look at the following (RDF/XML) example:

<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
 xmlns:dc="http://purl.org/dc/elements/1.1/"> 
  <rdf:Description rdf:about="http://www.w3.org/TR/hcls-swan/">
   <dc:title>Semantic Web Applications in Neuromedicine (SWAN) Ontology</dc:title>
   <dc:creator>Paolo Ciccarese</dc:creator>
   <dc:date>2009-10-20</dc:date>
   <dc:format>text/html</dc:format>
   <dc:language>en</dc:language>
  </rdf:Description>
</rdf:RDF>

Of the above example I want to focus on the following triple (Turtle syntax):

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

<http://www.w3.org/TR/hcls-swan/> dc:creator "Paolo Ciccarese".

Now if you take a look of the actual document I wrote where I appear as the Editor. It actually happened that somebody else created the file for that note and I've filled in the actual content. This situation is difficult to model using simply Dublin Core Element Set. Probably one way to go is to distinguish between the file and the content.

Another example. Let's say I want to create a file with a quote from a book or a speech. I create the HTML file (my resource). However, the actual content has been authored by somebody else. How do I represent it with Dublin Core Element Set. Let me give it a try:

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
 xmlns:dcterms="http://purl.org/dc/terms/" 
 xmlns:dc="http://purl.org/dc/elements/1.1/">
  <rdf:Description rdf:about="http://www.paolociccarese.info/example/quotes/1">
   <dc:title>My favourite quote</dc:title>
   <dc:creator>Paolo Ciccarese</dc:creator>
   <dc:date>2011-02-23</dc:date>
   <dc:format>text/html</dc:format>
   <dc:language>it</dc:language>
   <dcterms:hasPart>
     <rdf:Description>
       <dc:creator>Dante Alighieri</dc:creator>
       <dc:description>Lasciate ogni speranza, voi ch'entrate</dc:description>
     </rdf:Description>
   </dcterms:hasPart>
  </rdf:Description>
</rdf:RDF>

As you probably noticed I have not defined a URI for the quote and therefore the generated triples will include a blank node. I can also think of making up a URI like http://www.paolociccarese.info/example/quotes/1#quote as long as I can make it resolvable. The above snippet does more or less what I wanted to. Now, one thing I don't like is that Dante Alighieri and I are both creators. As a matter of fact, in the quote there is some intellectual property involved, while in the making of the simple HTML page, not so much. However this could lead to problems as drawing the lines is not easy. I could also consider the use of the property contributor - see the guideline here -, however I am not sure that is appropriate in the present case.

Principle: Traceability [1]

2011-02-18T06:16:00.001+01:00

According to Wikipedia:

Traceability refers to the completeness of the information about every step in a process chain.

I've been working on Clinical Information Systems for quite a while and traceability is a very well-known - even if usually poorly implemented - concept when talking about medical processes and patient data. For instance, for a blood pressure measurement, it is important to know who performed the procedure, where and when but also, if the notes have been written on paper first, who wrote the measures and when, eventually who entered the data in the system, where and when... if the information system is managing structured data, we might want to record the language of the operator who entered the data, the templates she used and so on... The main idea is to keep track of the process details and of all the accountable health care professionals. In the previous list, to make it simple, I voluntarily excluded the medical context - which cuff has been used, was the pressure measured after a meal, after physical activity - which is crucial for reproducibility but opens to multiple other representational issues. You would be amazed on how complicated the model for a blood pressure measurement can become.

But what is traceability in Semantic Web terms? I guess one way of saying it is through the term Provenance, very popular these days.

Provenance, from the French provenir, "to come from", means the, or the of something, or the history of the ownership or location of an object. The term was originally mostly used for works of art, but is now used in similar senses in a wide range of fields, including science and computing.

A good alternative definition, more focused on computing and, which takes into account processual aspects, is provided by the W3C Provenance Incubator Group:

Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance.

In my mind, traceability is still a more generic concept than provenance. For instance, I would consider some of the aspects required for reproducibility part of the traceability and not of the provenance. And this is because I believe it would be easier to standardize 'where, when and who' (what I consider provenance), than 'what, why, which, how' (which represent context that added to provenance gives traceability) that are domain dependent and can become very hard to define. However, the last definition makes me quite happy and I would be glad if the incubator for provenance will translate into an actual Working Group.

Principle: Adequate Documentation [1]

2011-02-15T20:20:00.002+01:00

This is trivial to understand. The documentation for an ontology is very important for adoption and for data sharing. This works for software as well. One thing I found always awesome regarding Java was the quality of the API documentation, the JavaDocs are cool and easy to generate. For ontologies the reality is a bit more complicated.

Some ontologies, including some of those I made, are just the pure RDFS/OWL file. Often with no descriptions whatsoever of the classes/properties. The understanding of those ontologies relies totally on the ability of the users to interpret the labels/names correctly. Other ontologies include very fuzzy, sometimes poor, descriptions - "Document: a document. The Document class represents those things which are, broadly conceived, 'documents'.". The interpretation relies mostly on the users' common sense. To be fair, in recent versions of the FOAF vocabulary, the previous definition is accompanied by a note saying: "We do not (currently) distinguish precisely between physical and electronic documents, or between copies of a work and the abstraction those copies embody. The relationship between documents and their byte-stream representation needs clarification". And let's be honest, defining what a document is nowadays, in the digital era, is not trivial. Is every file a document?

In the case of OBO Foundry, a set of principles has been defined. Here are some of them:

"The ontologies include textual definitions for all terms. Many biological and medical terms may be ambiguous, so terms should be defined so that their precise meaning within the context of a particular ontology is clear to a human reader."

"The ontology is well documented."

The thing is, definitions are a necessary step but that is not enough. When I talk about 'Adequate Documentation' I mean many different things: definitions, examples of use cases, examples of resulting triples, motivations, related projects... In other words, a good amount of shared knowledge about the ontology and the process that generated it.

Unfortunately there are no clear rules, I keep trying different ways of translating the most tacit knowledge I can into explicit and I can't say I found the right recipe yet. Definitions can certainly help, I find valuable to include explanations of the ontology building process where motivations behind the different choices are given, explanatory figures, plenty of examples with actual triples, maybe a list of Frequently Asked Questions where the authors can publicly address some of the concerns of real users. All this takes time and effort, and, by personal experience, can also cause collateral damage...

Which principles drive ontology adoption?

2011-02-13T19:25:00.000+01:00

Several weeks ago, I started to think of the next version of the Annotation Ontology (AO). After one year spent developing the Annotation Framework and discussing with several colleagues and friends, I certainly have a little list of things I want to improve. Nothing major, mostly a clean up.

Before proceeding with the updates, I wanted to better clarify the set of principles I want to follow in developing AO2. These are, in random order: Traceability, Orthogonality, Generality, Interoperability, Modularity, Extensibility, Adequate Documentation, Community Driven. The reason why I am listing this principles is important, I believe they influence adoption.

As you might have noticed the number of available ontologies is constantly increasing. If you need to use an ontology, you have to go through the process of revising what is out there, and selecting what you think is most appropriate. How many time have you done that? How many time did you succeed? How many times did you find the right ontology covering exactly what you needed? I am pretty sure that if you are involved in the development of a complex application the answer is something like: I found a few ontologies I could mix and match... I still need to add pieces... and, most importantly, I am not sure I agree on the way some or them are done. Right. Welcome to the Semantic Web I would say.

I remember the old days - many years ago - when Dublin Core Metadata Element Set, Version 1.1 (DC) was the answer to almost everything. When I started working on SWAN (Semantic Web Applications in Neuromedicine) in 2006 I found immediately DC to be insufficient for our needs. For days I've been struggling trying to understand what to do: use DC and being sloppy or create something more appropriate risking isolation and to increase the entropy of the Semantic Web world.

Well at that time my answer has been the Provenance, Authoring and Versioning Ontology (PAV) now available in version 2. The choice, at the time, has been dictated also by practical reasons: if I was using DC for Annotation Properties and I wanted to be OWL DL, I could not use it also for other properties. Since then, PAV has been used in our applications but also in several others developed by people/groups I barely know - sometimes I wish they just would tell me something like: "hey I am using PAV and it's cool" or even "hey I am using PAV and it sucks because...". PAV has also been considered as one of the starting points for the W3C Provenance Incubator Group.

PAV was not such a bad idea at the end. But it was a risky business. If you are developing an application you need always to keep an eye on what is existing and the other eye on your requirements. This results to be even more complicated because it is hard to find appropriate ontologies and, when you find them, they often don't have adequate documentation for you to understand that is what you are looking for. Surprise! The lack of shared knowledge about the ontology does not help it to emerge and does not help adoption... unless, of course, external factors - networking, important supporters, big institutions ... - come into play. And external factors are not little thing.

Creating annotation on HTML with the Annotation Framework

2011-02-04T23:02:00.000+01:00

This is a few weeks old screencast showing how I can visually create annotation on top of an HTML document. The annotation is then serialized in RDF according to the Annotation Ontology (AO).

Creating manual annotation with the Annotation Framework. from Paolo Ciccarese on Vimeo.

Annotation and Content Improvement

2011-01-31T01:43:00.000+01:00

I was recently attending the workshop 'Beyond the PDF' in San Diego and I noticed multiple times how the concept of 'Annotation' is often intended as a task performed after publication of a physical or digital document.

I consider Annotation to be more ubiquitous and important at all stages: before, during and after publication. Also, Annotation is not only about classic textual document. Images, database records and data-sets can be annotated as well. Even physical objects can be digitally annotated when we create a correspondent digital record or - speaking in terms of ontologies - when we refer to the representation of that particular instance of a certain class.

Annotation can exist as such forever or can be incorporated back in the original document/resource or a new version of the original document/resource. If you think at the old fashion paper encyclopedia, every year - or bunch of years - the editor was collecting the several annotations to come up with a new edition of the heavy volumes. This was very close to what in the digital world is called versioning.

In the modern digital world annotation is everywhere. Tags attached to a document are annotation. Leveraging crowdsourcing makes possible to include the most popular tags as keywords for that document. Delicious users are experiencing this anytime they are in the process to tag a new resource and they receive suggestions of popular or appropriate tags. Reviews of catalog items in Amazon are annotations and the statistical analysis of such results appears close to the selected item under the form of stars. To some extents, edits in a Wiki can be seen as annotation - and could be exported as such - where a user changes the current document content. However, I understand using the term Annotation for edits might sound a bit of a stretch.

Maybe, in today digital world, a better way to refer to this process is 'Content refinement' as everything can potentially be 'changed'. But even the term refine might fall short as 'to refine' means improving by making small changes. Sometimes edits are massive and an article in Wikipedia can evolve dramatically in time. It is not simply polishing and fixing, we can add/remove big chunks of the original documents - adding missing items or removing items that are redundant or not valid anymore - or can make the original document more actual - for instance adding new evidence that was not available when the document has been previously published. 'Content Improvement' is probably generic enough to cover refinements and edits.

Sure, I am talking of evolving documents but it does not preclude to take snapshots of it in a 'traditional publication' or in a version of that resource. Take online news. I realized more than once that the news at a specific URL was changing and journalists were incrementally adding new sections at the bottom of the page whenever the new updates were available. You might argue this is not good practice but it happens more often than what you think. The reason is simple: in the digital world, it is possible and cheap. We don't have to reprint a book or to add an errata page to avoid reprinting. We just create a note or directly edit the content - hopefully while keeping track of the changes.

I see many attempts to redefine what a publication is. These days, I believe publication is a multidimensional evolving artifact including images, videos, live tables, data, metadata... and no matter what it includes or what it looks like, it has to manage change or content improvement. Only snapshots of it, at particular times, would match the 'classic' concept of publication.

Books on my desk

2010-11-19T00:03:00.001+01:00

These days I have in the pipeline three books I want to browse/read. The first is a book I've read already months ago: Pro Spring Dynamic Modules for OSGi™ Service Platforms. The other two are: OSGi and Equinox: Creating Highly Modular Java Systems and Eclipse Rich Client Platform (2nd Edition). I guess my motivation is a re-visitation of the pool of technologies I've used years ago to develop JDPF (Java Data Processing Framework). I still believe OSGi is a terrific technology.

UIBinder, CSS and Images (GWT)

2010-11-09T20:07:00.037+01:00

I am working with GWT (Google Web Toolkit) since a while now. One of the things I am regularly doing (since version 2.0) is creating UIs through Declarative Layouts with UiBinder. While creating the ui.xml files it is normal to have the need of displaying images or icons.

1) Integrating background images with the ui:style section: for a long time have been using simple colors to create my look and feel but lately I started to feel the need to give the UI a better look using images as background. One way of getting this done with GWT is to include in the ui.xml file something like this - where the image is in the same folder of the ui.xml file:

<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
xmlns:g='urn:import:com.google.gwt.user.client.ui'>

  <ui:style>
    @url fileUrl bckImage;
    .titleBar { background: fileUrl repeat 0 0; }
  </ui:style>

  <ui:data field='bckImage' src='image.gif'/>

  <g:HorizontalPanel styleName='{style.titleBar}'>
  ...
  </g:HorizontalPanel>

</ui:UiBinder>

An alternative way:

<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
xmlns:g='urn:import:com.google.gwt.user.client.ui'>

  <ui:image field='gradient' src='image.gif' />

  <ui:style>
    @sprite .header {
      gwt-image: 'gradient';
      width: 100%;
      height: 18px;
    }
  </ui:style>

  <g:VerticalPanel>
    <g:HorizontalPanel ui:field='header' styleName='{style.header}'/>
  </g:VerticalPanel>

</ui:UiBinder>

2) Getting the images from the ClientBundle: in GWT it is possible to declare resources with something like the following:

package com.commonsemantics.example;

public class Example implements EntryPoint {

  public interface Resources extends ClientBundle
  {
     public static final Resources INSTANCE =  GWT.create(Resources.class);

     @Source("images/myIcon.jpg")
     ImageResource myIcon();
  }

  ...
}

Once the ImageResource is declared it is possible to use it in the ui.xml file:

<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
xmlns:g='urn:import:com.google.gwt.user.client.ui'>

  <ui:style>
    .myImage { width: 18px; height: 18px; }
  </ui:style>

  <ui:with field='resources'
    type='com.commonsemantics.example.Example.Resources' /> 

  <g:HorizontalPanel styleName='{style.titleBar}'>
    <g:Image ui:field='rightSide' resource='{resources.myIcon}'  
      styleName='{style.myImage}'></g:Image>
  </g:HorizontalPanel>

  </ui:UiBinder>

3) Getting the images from the same package. When making use of images it is also possible to copy them in the same package of the class using them and refer to them as follow:

<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
xmlns:g='urn:import:com.google.gwt.user.client.ui'>

  <ui:style>
    .myImage { width: 18px; height: 18px; }
  </ui:style>

  <ui:image field='myImage' src='myImage.gif' />

  <g:HorizontalPanel>
    <g:Image ui:field='rightSide' resource='{myImage}'  
      styleName='{style.myImage}'></g:Image>
  </g:HorizontalPanel>

</ui:UiBinder>

About one of my FOAF problems

2010-05-27T21:50:00.013+02:00

I am currently involved in defining the Annotation Ontology (AO). For this tasks I would like to be able to reuse existing ontologies and AO is actually built on top of the Annotea project schema. Another popular vocabulary would be FOAF. Now, FOAF defines - or better loosely defines - a foaf:Document class as: The Document class represents those things which are, broadly conceived, 'documents'. Also in the documentation (accessed today) I read: there is no distinction between physical or electronic documents.

In AO I need to point to the document I am annotating. As many of you might know, documents on the web, even if they have the same URI, are subject to change. For instance my curriculum is changing with the new projects I am working on. Unfortunately the URI is always the same. Therefore, it might be that I annotate a piece of text in a document today and, tomorrow that piece is gone and my annotation is orphan.

To be clear I can write something like:

<rdf:Description rdf:about="http://www.hcklab.org/paolo-ciccarese-cv.html">
  <rdf:type rdf:resource="Document"/>             
  <pav:sourceAccessedOn>2010-05-10</pav:sourceAccessedOn>
</rdf:Description>

After a while some other user (or myself again) creates some other annotation; this will result in:

<rdf:Description rdf:about="http://www.hcklab.org/paolo-ciccarese-cv.html">
  <rdf:type rdf:resource="Document"/>             
  <pav:sourceAccessedOn>2010-05-31</pav:sourceAccessedOn>
</rdf:Description>

As you can imagine, the access date is not working well as now we have a URI associated with two dates and there is no way to distinguish which date is associated to what annotation.

A better solution would be to have a stable URI for the webpage and a different URI for each version of the document. Something like:

<rdf:Description rdf:about="http://my.example.org/sd/2332">
  <rdf:type rdf:resource="Document"/>
  <ao:retrievedFrom rdf:resource="http://tinyurl.com/ykjn87p"/>
  <pav:sourceAccessedOn>2010-05-10</pav:sourceAccessedOn>
</rdf:Description>>

<rdf:Description rdf:about="http://tinyurl.com/ykjn87p">
  <rdf:type rdf:resource="WebPage"/>
</rdf:Description>

or, if we really want to keep FOAF in the picture:

<rdf:Description rdf:about="http://my.example.org/sd/2332">
  <rdf:type rdf:resource="SourceDocument"/>
  <ao:retrievedFrom rdf:resource="http://tinyurl.com/ykjn87p"/>
  <pav:sourceAccessedOn>2010-05-10</pav:sourceAccessedOn>
</rdf:Description>>

<rdf:Description rdf:about="http://tinyurl.com/ykjn87p">
  <rdf:type rdf:resource="http://xmlns.com/foaf/0.1/Document"/>
</rdf:Description>

Genius for gene networks

2010-04-09T17:32:00.012+02:00

Now that I cleaned the matrix data (see previous three posts) I can display them with Genius (google code) without having to deal with long genes descriptions:

First steps with Gridworks (3)

2010-04-09T16:08:00.011+02:00

Once again I go back to the original file and, as I know that the first column has always the same format I will try: value.split(":")[-1] and the results will be:

And here we go:

In this case I've created a new column but I could have selected 'edit cell -> transform' to transform the original column directly.

Finally, to create exactly what I wanted:
value.split(':')[-2]+':'+value.split(':')[-1]
or
value.replace('Affymetrix:CompositeSequence:','')
or
value.split(':')[2,4].join(':')

In summary, with the last line of code, in a few seconds total (load the file and run the command) I can perform the desired transformation. Also, it would be helpful to be able to use the command "split multi-valued cells" with the choice of splitting into rows (as it is already possible now) or into columns (which is currently not possible).

First steps with Gridworks (2)

2010-04-09T04:25:00.013+02:00

I am back on the 'Genius matrix' project and I notice that the column name is a bit cryptic, I therefore provide a new simple name.

Even if that was not the goal of my data cleaning I am still curious on how to split the first column in multiple ones using the separator ':' as criteria.

I select 'add column based on this column' and I get the following screen:

Using the "Gridworks Expression Language" (GEL) I can create a new column where I got rid of the prefix "Affymetrix:CompositeSequence" (as you can see in the above pic):

if(value.startsWith ("Affymetrix:CompositeSequence"), value.substring(29), value)

And the result is:

I still haven't used the separator ':' with my rule but the result is really close to what I wanted... and there is always the option to roll back.

First steps with Gridworks (1)

2010-04-08T14:40:00.017+02:00

I am having the chance of testing the alpha of Freebase Gridworks and given my appreciation for the work of David Huynh and Stefano Mazzocchi I am really excited about it. As these days I am working on a little software for visualizing gene networks and I need to perform a few simple steps for cleaning the data I decided to go Gridworks (video1 and video2). Gridworks is easy to install and once I run it, Gridworks opens a page in my browser.

I am then going to load a matrix in csv format simply filling in the data file location and a project name. Creating the project I get back the view of the matrix:

I now need to clean the first column that contains names such as:
Affymetrix:CompositeSequence:Rat230_2:1389668_at

and change them into something like: Rat230_2:1389668But first I want to visualize a larger number of rows (from 20 to 50) to make sure that the pattern is always the same. I select page size: 50 and this time the operation takes a few seconds to complete.
Now I want to find the best way to modify the first column and I start exploring the contextual menu:

Several quick options are available: transform to uppercase, lowercase, title case, collapse white spaces and so on. I also see a split multi-valued cells and this gets my attention. I select it, I specify as separator the semicolumn ':' and I get back:

This is not exactly what I wanted as I was expecting to get multiple columns out of the first one instead of getting multiple rows. Well, no problem the undo feature is one click away. You can either click on the top of the screen for the last command undo or you can browse the command history on the right of the screen and go back the desire amount of steps.

And I can go back to the original state.

Talking about SWAN (Semantic Web Applications in Neuromedicine)

2010-02-22T00:38:00.002+01:00

An article entitled, "SWAN: The Powerful Research Organizer", is on this week's Alzheimer's Weekly home page (02/21/2010)

Several paragraphs about SWAN have been published in the Nature News Speed Reading (Nature vol 463, 28 January 2010)

Heat-shock Proteins Families

2009-10-29T03:29:00.006+01:00

Heat-shock proteins are named according to their molecular weight (kilodaltons):

Approximate molecular weight (kDa)	Eukaryotic proteins	Function
10 kDa	Hsp10	Co-factor of Hsp60. Chaperonins: protein complexes that assist the folding of these nascent, non-native polypeptides into their native, functional state.
20-30 kDa	The HspB group of Hsp. Ten members in mammals including Hsp27 or HspB1
40 kDa	Hsp40	Co-factor of Hsp70
60 kDa	Hsp60	Involved in protein folding after its post-translational import to the mitochondrion/chloroplast
70 kDa	The HspA group of Hsp including Hsp71, Hsp70, Hsp72, Grp78 (BiP), Hsx70 found only in primates	Protein folding and unfolding, provides thermotolerance to cell on exposure to heat stress. Also prevents protein folding during post-translational import into the mitochondria/chloroplast.
90 kDa	The HspC group of Hsp including Hsp90, Grp94	Maintenance of steroid receptors and transcription factors
100 kDa	Hsp104, Hsp110	Tolerance of extreme temperature

The Hsp70/Hsp40 Family (Chaperone)

The 70 kilodalton heat shock proteins (Hsp70s) are a family of highly-related protein isoforms ranging in size from 66 kDa to 78 kDa. Proteins with similar structure exist in virtually all living organisms. The Hsp70s are an important part of the cell's machinery for protein folding, and help to protect cells from stress. The various family members are distributed throughout different intracellular compartments but nevertheless share many structural and biochemical properties.

These include: the cytosolic/nuclear Hsp70 proteins Hsc70 (a.k.a. Hsp73) and Hsp70 (a.k.a. Hsp72), Grp78 or Bip present within the lumen of the endoplasmic reticulum, and Grp75 (also called mortalin) localized within mitochondria. Hsc70 is constitutively expressed and poorly stress-inducible, whereas Hsp70 is unabundant in normal physiological situations and strongly induced under oxidative stress. Hsc70 was placed in the heat shock protein family due to homology with other heat shock proteins.

All of the mammalian Hsp70 family members require one or more cochaperones for their reaction cycle (HSP40 or HSP100).

The Hsp60/Hsp10 Family (Chaperonins)

The HSP60 (GroEL - Prokaryotic) proteins in combination with its particular co-factor Hsp10 (GroES - Prokaryotic) bind newly synthesized polypeptides and facilitate their folding to the native state in an ATP-dependent cycle. The binding and sequestration of the substrate polypeptide occurs within the large central cavity of the chaperonin complex. It is thought that protection of the substrate protein within the central cavity of the chaperonin provides a sequestered protein folding environment, thereby reducing the probability of misfolding and aggregation of the target protein with other polypeptides. The chaperonins together with Hsp70 chaperones coordinate the efficient folding and assembly of many proteins throughout the cell.

Hsp60 families are highly immunogenic proteins. The related GroEL proteins from different pathogens elicit strong humoral and cellular immune responses.

In mammalian the Hsp60 is localized within mitochondria and with its cochaperone, Hsp10, participates in the folding and assembly of newly synthesized proteins as they are transported into the mitochondria from the cytosol.

Hsp90

Hsp90 is a molecular chaperone and is one of the most abundant proteins expressed in cells. Unlike some of the other well characterized heat shock proteins whose chaperone role involves their interaction with many cellular proteins, Hsp90 exhibits some selectivity for a distinct set of “client” proteins. Hsp90 interacts with a variety of protein kinases and transcription factors important for growth and development. Working with its very large number of cochaperones, Hsp90 appears to maintain its client proteins in a conformation that allows for their subsequent activation in response to appropriate growth signals. Not surprisingly, Hsp90 and its co-chaperones are at the forefront of research for those studying signal transduction events and cancer.

Sources

Heat Shock and Heat Shock Proteins

2009-10-29T01:57:00.004+01:00

Heat Shock

In biochemistry, heat shock is the effect of subjecting a cell to a higher temperature than that of the ideal body temperature of the organism from which the cell line was derived. In fish that survive at 0°C, heat shock can be induced with temperatures as low as 5°C, whereas thermophilic bacteria that proliferate at 50°C will not express heat shock proteins until temperatures reach approximately 60°C. The process of heat shocking can be done in a CO2 incubator, O2 incubator, or a hot water bath.

Induction of heat shock is a method by which genes can be introduced into cells via a vector. This is done by mixing the vector with competent bacteria in a microcentrifuge tube. First, the tube is cooled to a low temperature for several minutes, usually with an ice bath. The tube is then quickly moved into warm water, preferably around 42°C. This sudden change in temperature causes the pores to open up to larger sizes, allowing DNA molecules to enter. After a brief interval, the tube is quickly cooled to a low temperature again. This closes up the pores, and traps the DNA inside. With this, the cells would have been transformed. However, as with almost all transformation techniques, this method is far from 100% efficient.

from Wikipedia (accessed on 10/28/2009)

Heat Shock Proteins

Heat shock proteins (HSPs) are present in cells under normal conditions (1), but are expressed at high levels when exposed to a sudden temperature jump or other stress (2).

(1) HSPs act like ‘chaperones,’ making sure that the cell’s proteins are in the right shape and in the right place at the right time. For example, HSPs help new or distorted proteins fold into shape, which is essential for their function. Heat shock proteins also shuttle proteins from one compartment to another inside the cell, and transport old proteins to ‘garbage disposals’ inside the cell. Heat shock proteins are also believed to play a role in the presentation of pieces of proteins (or peptides) on the cell surface to help the immune system recognize diseased cells. HSPs appear to serve a significant cardiovascular role.

Chaperones are proteins that assist the non-covalent folding/unfolding and the assembly/disassembly of other macromolecular structures, but do not occur in these structures when the latter are performing their normal biological functions. Chaperones do not necessarily convey steric information required for proteins to fold: thus statements of the form `chaperones fold proteins` can be misleading. One major function of chaperones is to prevent both newly synthesised polypeptide chains and assembled subunits from aggregating into nonfunctional structures. It is for this reason that many chaperones, but by no means all, are also heat shock proteins because the tendency to aggregate increases as proteins are denatured by stress. However, 'steric chaperones' directly assist in the folding of specific proteins by providing essential steric information.

Heat shock proteins trigger immune response through activities that occur both inside the cell (intracellular) and outside the cell (extracellular).

Intracellular activities: Because of the normal functions of heat shock proteins inside the cell (such as helping proteins fold, preparing proteins for disposal, etc.), HSPs end up binding virtually every protein made within the cell. This means that at any given time, HSPs can be found inside the cell bound to a wide array of peptides that represent a ‘library’ of all the proteins inside the cell. This library contains normal peptides that are found in all cells as well as abnormal peptides that are only found in sick cells. Research suggests that inside the cell, heat shock proteins take the peptides and hand them over to another group of molecules. These other molecules take the abnormal peptides that are found only in sick cells and move them from inside the cell to outside on the cell’s surface. When the abnormal peptides are displayed in this way, they act as red flags, warning the immune system that the cell has become sick. These abnormal peptides are called antigens — a term that describes any substance capable of triggering an immune response.
Extracellular activities: Heat shock proteins are normally found inside cells. When they are found outside the cell, it indicates that a cell has become so sick that it has died and spilled out all of its contents. This kind of messy, unplanned death is called necrosis, and only occurs when something is very wrong with the cell. Extracellular HSPs are one of the most powerful ways of sending a ‘danger signal’ to the immune system in order to generate a response that can help to get rid of an infection or disease.

(2) HSPs are a part of the cell's internal repair mechanism. They are also called stress-proteins. They respond to heat, cold and oxygen deprivation by activating several cascade pathways. In fact, HSPs stabilize proteins and are involved in the folding of denatured proteins. High temperatures and other stresses, such as altered pH and oxygen deprivation, make it more difficult for proteins to form their proper structures and cause some already structured proteins to unfold. Left uncorrected, mis-folded proteins form aggregates that may eventually kill the cell. HSPs are induced rapidly at high levels to deal with this problem. Increased expression of HSPs is mediated at multiple levels: mRNA synthesis, mRNA stability, and translation efficiency.

Heat shock factor 1 (HSF-1) is the major regulator of heat shock protein transcription in eukaryotes. In the absence of cellular stress, HSF-1 is inhibited by association with heat shock proteins and is therefore not active. Cellular stresses, such as increased temperature, can cause proteins in the cell to misfold. Heat shock proteins bind to the misfolded proteins and dissociate from HSF-1. This allows HSF1 to form trimers and translocate to the cell nucleus and activate transcription.

from Wikipedia (accessed on 10/28/2009), from Wikipedia (accessed on 10/28/2009), from Wikipedia (accessed on 10/28/2009), from Wikipedia (accessed on 10/28/2009)

Eclipse+Grails+GWT: Integrating 'live' GWT [1]

2009-10-23T20:13:00.017+02:00

After creating a Grails project in Eclipse (and a plugin), I want now to make use of GWT (Google Web Toolkit). For doing so I am going first to install the useful Google plugin for Eclipse (download). As I am working with Eclipse Galileo, I am installing the software using: http://dl.google.com/eclipse/plugin/3.5

If you are new to GWT I would suggest you to start creating a simple GWT project (without any Grails involved). Follow this.

Adding the gwt libraries to the classpath of the Grails project

If you installed the Eclipse plugin for GWT this would be a fairly simple step. Right click on the project and Properties->Java Build Path->Libraries->Add Library and I will find in the list the Google Web Toolkit in the list (this is obviously because I previously succesfully installed the Eclipse plugin for GWT).

An alternative way (to the Google plugin) would have been to define in the Eclipse Preferences->Java->Build Path->Classpath Variables the variable GWT_HOME that will point to the gwt installation (i.e. /Users/paolociccarese/Library/gwt-mac-1.7.1). If you haven't installed GWT yet, you can download it here. Then we are going to add to the libraries of the 'FirstApp' projects the jars included in the GWT distribution (Right click on the project and Properties->Java Build Path->Libraries->Add variable you can select GWT_HOME and extend it with the jars: gwt-api-checker, gwt-dev-mac, gwt-servlet, gwt-user.

Another way would be using ivy for resolving the dependencies.

The Grails plugin for GWT

Then I will install the Grails plugin for GWT. Once again, after positioning in the root of the 'FirstApp' project I will type:
> grails install-plugin gwt

At this point I am almost ready to go...

Eclipse+Grails: Adding a 'live' plugin to the project

2009-10-19T15:45:00.021+02:00

Once created the new project 'FirstApp' I want to be able to create a Grails plugin in the Eclipse IDE. To create a plugin is pretty straightforward, I use the command line, after positioning in the root of the current workspace, and I type:
> grails create-plugin FirstPlugin

The Grails plugin structure is almost identical to the Grails application structure. See my previous post about the Grails plugin. I am going to import in Eclipse the plugin with the classic 'Import as Existing Project'. As I did for the 'FirstApp' I can enable the Groovy capabilities right clicking on the project and selecting: Configure-> Convert to Groovy project. Also, exactly as I did for the Grails application, I select the ivy.xml file, I right-clik and select 'Add Ivy Library...'. This will link, through ivy, all the libraries necessary to the newly created Grails application to compile and run. Once performed this step I can safely remove all the libraries linked in the subdirectory GRAILS_HOME from the Properties->Java Build Path. You should also notice a new icon in the toolbar with tooltip 'Resolve All Dependencies'. You can use that icon to retrieve new dependencies that you specified in the ivy.xml file.

For testing purposes I can run the plugin as it was an application with:
> grails run-app

After checking that the plugin can run I want to use the Grails plugin 'FirstPlugin' in the Grails application 'FirstApp'. The 'classic' way would be to package the plugin by command line. After positioning in the root of the plugin:
> grails package-plugin
will create a file like grails-firstplugin-0.1.zip. After positioning in the root of the app, I can then the installation of the plugin:
>grails install-plugin ../FirstPlugin/grails-firstplugin-0.1.zip

Unfortunately, this approach is really annoying and time consuming when using the Eclipse framework. In fact, every time the plugin is changing I have to package it again and install it again.

Well, in Eclipse there is a better way to go. First of all we create the file conf/BuildConfig.groovy in the 'FirstApp' project. In this file we are going to type:
grails.plugin.location.firstPlugin = "../FirstPlugin"

This will basically tell Grails to refer to that plugin specifying the plugin folder. To test this, after creating the file, you can proceed creating a controller in the plugin. After positioning in the plugin root, I type:
>grails create-controller org.example.First

This will generate a new controller org.example.FirstController .To prove that the BuildConfig.goovy file is working you can run the application. After positioning in the root of the application:
>grails run-app

Checking the URL: http://localhost:8080/FirstApp/ you should see the controller (of the plugin) showing up. There is still a problem though if you create a second controller (or a change in the code of the plugin), this will not show up in the application unless you restart the server. This might become extremely annoying on the long run.

The solution to that is the creation of a soft link. We are going to create a link to the plugin project inside the code of the application. First I create the directory plugins in the FirstApp project:
>mkdir plugins

Then, in that directory, I am going to create the link to the FirstPlugin:
>ln -s ../../FirstPlugin

Right. Now, if you followed correctly (...and if I have not forgot any step), while the server is running, you should be able to create a new controller in the 'FirstPlugin' and see it in the list of the controllers in the running application: http://localhost:8080/FirstApp/

One more thing, remember to refresh the eclipse project every time you make use of a Grails command that creates/modify files.

Eclipse+Grails: Setting up a new project

2009-10-19T03:46:00.022+02:00

Here is my current setup for creating a Grails project with Eclipse:

Installed Eclipse jee 3.5 Galileo SR1 (download)
Installed SVN plugin Subclipse (Update site: http://subclipse.tigris.org/update_1.6.x)
Installed Groovy plugin (Update site: http://dist.codehaus.org/groovy/distributions/greclipse/snapshot/e3.5/)
Installed Ivy plugin (http://www.apache.org/dist/ant/ivyde/updatesite)

I am then going to setup the launcher for the Grails commands through the "External Tools Configuration". I am specifying the 'location of Grails" (i.e. /Users/paolociccarese/Library/Grails-1.1.1/bin/grails), then ${project_loc} as 'Working directory' (that means the command will be related to the selected project in the Eclipse workspace. Finally I define as 'Arguments': ${string_prompt} . This will allow me to run the Grails commands like I would do from the command line. To be honest I also use the command line when I am managing grails projects, for some operations is more practical.

Finally I create the GRAILS_HOME variable in Eclipse->Preferences->Java->Build Path->Classpath Variables. This is used by Eclipse to compile the project. You may notice that GROOVY_HOME and IVY_HOME have already been created by the plugins.

Now I want to create a new Grails application that I will call 'FirstApp'. For doing this I will use the command line and, after positioning myself in the root of the current workspace, I type:
> grails create-app FirstApp

This will create the structure of my new application (in the newly created directory: FirstApp). I can now import this structure as 'Import as Existing Project' in my workspace. I can enable the Groovy capabilities right clicking on the project and selecting: Configure-> Convert to Groovy project.

Now if you right-click on the project and select: Properties->Java Build Path you will notice tha all the libraries are linked in a subdirectory of GRAILS_HOME. This is not my solution as I want to be dependent from the ivy.xml file. To do so, I select the ivy.xml file, I right-clik and select 'Add Ivy Library...'. This will link, through ivy, all the libraries necessary to the newly created Grails application to compile and run. Once performed this step I can safely remove all the libraries linked in the subdirectory GRAILS_HOME from the Properties->Java Build Path. You should also notice a new icon in the toolbar with tooltip 'Resolve All Dependencies'. You can use that icon to retrieve new dependencies that you specified in the ivy.xml file.

Now I can test if the application is actually running. I select a file in the project and I run the external application 'Grails' that I previously created. A window will pop up and we can fill out the text box with the command 'run-app'. The alternative would have been to use the shall and, after positioning in the root of the project, type:
> grails run-app

If everything went right we can now browse: http://localhost:8080/FirstApp/ getting back the Grails welcome screen.

Uploading RDF vocabularies (GRAILS, Virtuoso and Sesame)

2009-09-16T22:11:00.022+02:00

If you need to upload an RDF vocabulary in Virtuoso, the easiest way to go is doing it through the Virtuoso Conductor. It is pretty straightforward, you define the graph name and the file to upload and that is it. When developing an application though, you may want to be able to upload the files programmatically (for instance for managing metadata associated to the vocabulary and creating a catalog).

The following snipped of code is a modified version of the one I found in the openrdf forum:


Repository myRepository = new VirtuosoRepository("jdbc:virtuoso://localhost:1111","dba","dba");
myRepository.initialize();
File file = new File("/Users/paolociccarese/Desktop/contact.rdf");
RepositoryConnection con = myRepository.getConnection();
URI context = new URIImpl("http://paolociccarese.info/contact");
con.add(file, null, RDFFormat.RDFXML, context);
con.close();

For running this code it is necessary to perform a bunch of imports:


import org.openrdf.model.URI;
import org.openrdf.model.impl.URIImpl;
import org.openrdf.rio.RDFFormat
import org.openrdf.repository.Repository
import org.openrdf.repository.RepositoryConnection

To make it work, if you use grails and ivy (ivy.xml), you should add at least the following dependencies:

<dependency org="org.openrdf" name="openrdf-repository-api" rev="2.0.1" conf="compile"/>
<dependency org="org.openrdf" name="openrdf-rio-rdfxml" rev="2.0.1" conf="compile"/>
<dependency org="org.openrdf" name="openrdf-model" rev="2.0.1" conf="compile"/>

and you also need to link to the maven repository for these in the ivysettings.xml file:

<ibiblio name="aduna" root="http://repository.aduna-software.org/maven2" m2compatible="true"/>

and finally run the command >grails get-dependencies again.

Grails: Multiple datasources without GORM

2009-09-11T02:35:00.019+02:00

Who's playing around with Grails knows about GORM. GORM is Grails' object relational mapping (ORM) implementation. GORM is built on the top of Hibernate and enables persistence. The configuration of the database used for persistence is in the file grails-app/conf/DataSource.groovy. The application might need to access other databases for reasons other than persistence. It might be necessary to distinguish different sources for development, test or production (the Grails standard environments). In this case it is possible to leverage Spring creating the file grails-app/conf/srping/resources.groovy with a content similar to the following, which is setting up the connection to the Virtuoso triple store:


import org.apache.commons.dbcp.BasicDataSource

/*
* @author Paolo Ciccarese
*
* The virtuoso data source has been defined here to not
* interfere with the GORM datasource in the file
* grails-app/conf/DataSource.groovy
*/

beans = {
// Virtuoso triple store
virtuosoDataSourceDevelopment(BasicDataSource) {
   driverClassName = "virtuoso.jdbc3.Driver"
   url="jdbc:virtuoso://localhost:1111"
   username="dba"
   password="dba"
}
virtuosoDataSourceTest(BasicDataSource) {
   driverClassName = "virtuoso.jdbc3.Driver"
   url="jdbc:virtuoso://blah.org:1111"
   username="dba"
   password="dba"
}
virtuosoDataSourceProduction(BasicDataSource) {
    // Here the details of the production data source
}
}

BasicDataSource has been used as it guarantees connection pooling. In some examples, instead of that class you can find org.springframework.jdbc.datasource.DriverManagerDataSource . Reading the documentation: This class is not an actual connection pool; it does not actually pool Connections. It just serves as simple replacement for a full-blown connection pool, implementing the same standard interface, but creating new Connections on every call. This might create problems with Virtuoso in the case of numerous queries. Once we defined the data sources it is possible to define a service (> grails create-service) for providing the right one according to the current environment:

class SparqlService {

 def transactional = false

 def virtuosoDataSourceProduction
 def virtuosoDataSourceDevelopment
 def virtuosoDataSourceTest

 private static final String TEST = "test"

 def getDataSource() {
     if(grails.util.GrailsUtil.isDevelopmentEnv())
         return virtuosoDataSourceDevelopment
     else if(grails.util.GrailsUtil.getEnvironment()==TEST)
         return virtuosoDataSourceTest
     else
         return virtuosoDataSourceProduction
 }
}

Now it will be possible, for other services to use the one just defined. Something like:

class SparqlQueryService {
 
     def sparqlService

     boolean transactional = false
 
     public List<Map<String, Object>> getSparqlResultRowMaps(String query){
         log.info("Running query: " + query);
         JdbcTemplate jdbcTemplate = new JdbcTemplate(sparqlService.getDataSource())
        .....
         return results;
     }

....
}

Where the sparqlService is injected. Thus when a query is needed is sufficient to refer to sparqlQueryService, which will take care of selecting the right datasource.

The Grails plugin class

2009-09-04T17:17:00.006+02:00

Image via Wikipedia

After creating the plugin structure one thing you can do is to edit the Grails plugin class. The grails plugin class, by default, looks something like this:

class UtilsGrailsPlugin {
// the plugin version
def version = "0.1"
// the version or versions of Grails the plugin is designed for
def grailsVersion = "1.1.1 > *"
// the other plugins this plugin depends on
def dependsOn = [:]
// resources that are excluded from plugin packaging
def pluginExcludes = ["grails-app/views/error.gsp"]

// TODO Fill in these fields
def author = "Your name"
def authorEmail = ""
def title = "Plugin summary/headline"
def description = '''\\
Brief description of the plugin.
'''

// URL to the plugin's documentation
def documentation = "http://grails.org/Utils+Plugin"

....
}

As we are writing our first plugin there are not dependencies we want to define. We will simply fill out some details:

def author = "Paolo Ciccarese"
def authorEmail = "paolo.ciccarese@gmail.com"
def title = "Utilities for vocabularies/ontologies management"
def description = '''\\
Utilities for vocabularies/ontologies management
'''

You might want also to define the location of the documentation. This file will be used to generate the plugin package when needed. It is sufficient to be in the root directory of the plugin and type:
> grails package-plugin

This will create a grails-utils-0.1.zip file that can be then installed by other grails plugins/applications. To install it will be sufficient to be in the new application/plugin root directory and to type
> grails install-plugin grails-utils-0.1.zip

But before doing this, you probably have to write some code that will provide actual utilities.

A few mins with Grails (Creating a plugin)

2009-09-04T03:54:00.038+02:00

Image via Wikipedia

Lately I found myself playing around with Grails and I've been appreciating right away the plugins mechanism (Grails website: creating a Plugin).

With a simple:
> grails create-plugin Utils

or even with a simpler (the script will ask you to specify the name of the plugin later on):
> grails create-plugin

you will be able to generate the structure of a Grails plugin that you will notice is really similar to the structure of a Grails application (in italic the directories):

.classpath -> Eclipse .classpath file. It includes all the references to the folders in the project that are going to be in the classpath and all the references to the libraries for making your grails project run. The libraries are expressed through the GRAILS_HOME variable under the form GRAILS_HOME/dist/grails-web-1.1.1.jar. The directories that are included in the classpath are typically (you can detect them easily in Eclipse if you import the project just created as "existing project"):

src/java
src/groovy
grails-app/conf
grails-app/controllers
grails-app/domain
grails-app/services
grails-app/taglib
test/integration
test/unit

.project -> Eclipse .project file
.settings -> Eclipse .settings directory

Utils-test.launch -> can be used to run the unit tests
Utils.launch -> can be used to run the application
Utils.tmproj

UtilsGrailsPlugin.groovy -> The plugin class defines the version of the plugin and optionally various hooks into plugin extension points.

application.properties -> Contains a few lines to describe the details of the plugin/application:

#utf-8
#Fri Sep 04 10:12:01 EDT 2009
app.version=0.1
app.servlet.version=2.4
app.grails.version=1.1.1
app.name=Utils

build.xml -> It is an Ant file that contains a set of targets, allowing to resolve dependencies declared in the Ivy file, to compile and run the sample code, produce a report of dependency resolution, and clean the cache or the project. Ivy is a subproject of Ant.
grails-app -> directory containing the main components of a Grails application/plugin: controllers, services... (see classpath)
ivy.xml -> Ivy file containing the description of the dependencies of a module. Ivy (Ivy website) supports dependency resolution (grails does not support Maven).
ivysettings.xml -> file for Ivy configuration
lib -> directory containing the list of libraries for running the application
scripts -> Grails scripts
src -> directory with the source codes in both java and groovy (see classpath)
test -> directory collecting all Grails unit tests: Grails supports the concepts of unit and integration testing. Unit testing is for small focused, fast loading tests that don't load supporting components. Integration testing is for tests that load the surrounding environment (it supports injection).
web-app -> contains the web components of the Grails project

Moving towards the SWAN Collections Ontology [2]

2008-12-31T17:23:00.050+01:00

The idea of reasoning with sequential structures in OWL-DL is appealing. However, as already mentioned, we cannot use the RDF vocabulary in OWL-DL.

Drummond et al. [1] proposed a way of representing sequential structures in OWL-DL. Analyzing the work of Hirsh & Kudenko [2] Drummond argued that "their representation requires extensive rewriting, the relation of the resulting structures to the original lists is not intuitive and, more importantly, the resulting structures grow as the square of the length of the list". Then, he describes a general list pattern, an intuitive approach related to that suggested by Hayes [3] and incorporated in the Semantic Web Best Practice Working Group’s note on n-ary relations.

The list pattern works as follow:
Each item is held in a “cell” (OWLList); each cell has 2 pointers, one to a head (hasContents - functional) and one to the tail cells (hasNext - functional); the end of the list is indicated by a terminator (EmptyList) which also serves to represent the empty list. A transitive property, isFollowedBy, as a super-property of hasNext as been defined as well. In other words the members of any list are the contents of the first element plus the contents of all of the following elements. A separate OWL vocabulary has been defined as the RDF vocabulary cannot be used in OWL-DL.

Through the transitive property followedBy it is possible to ask things like: give me all the items that are followedBy "AC" for instance and it doesn't matter what is in between the item and the sequence itself.

In Manchester Syntax:

OWLList can express:

For instance for the pattern (A*):

List_only_As --> List AND
hasContents ONLY A AND
isFollowedBy ONLY (List AND hasContents ONLY A)

Still, in OWL-DL there are a bunch of constraints that cannot be defined (and I would suggest to read the paper for the complete list).

The list ontology page.

[1] Nicholas Drummond, Alan Rector, Robert Stevens, Georgina Moulton, Matthew Horridge, Hai Wang and Julian Sedenberg (2006). Putting OWL in Order: Paterns for sequences in OWL. OWL Experiences and Directions (OWLED 2006), Athens, Georgia, USA.
[2] Hirsh, H. and D. Kudenko. Representing Sequences in Description Logics. in Fourteenth National Conference on Artificial Intelligence. 1997.
[3] Noy, N.F. and A. Rector, N-ary relations. 2004, Editors Draft, Semantic Web Best Practices Working Group, W3C.

Moving towards the SWAN Collections Ontology [1]

2008-12-30T21:49:00.068+01:00

RDF Containers
RDF allows the usage of three kinds of containers:

rdf:Bag - A Bag represents a group of resources or literals, possibly including duplicate members, where there is no significance in the order of the members. For example, a Bag might be used to describe a group of part numbers in which the order of entry or processing of the part numbers does not matter.
rdf:Seq - A Sequence or Seq represents a group of resources or literals, possibly including duplicate members, where the order of the members is significant. For example, a Sequence might be used to describe a group that must be maintained in alphabetical order.
rdf:Alt - An Alternative or Alt represents a group of resources or literals that are alternatives (typically for a single value of a property). For example, an Alt might be used to describe alternative language translations for the title of a book, or to describe a list of alternative Internet sites at which a resource might be found. An application using a property whose value is an Alt container should be aware that it can choose any one of the members of the group as appropriate.

For example, a statement about "The resolution was approved by the Rules Committee, having members Fred, Wilma, and Dino" will have the form in triples:

ex:resolution exterms:approvedBy ex:rulesCommittee .
ex:rulesCommittee rdf:type rdf:Bag .
ex:rulesCommittee rdf:_1 ex:Fred .
ex:rulesCommittee rdf:_2 ex:Wilma .
ex:rulesCommittee rdf:_3 ex:Dino .

and this is much better than:

ex:resolution exterms:approvedBy ex:Fred .
ex:resolution exterms:approvedBy ex:Wilma .
ex:resolution exterms:approvedBy ex:Dino .

since these statements say that each member individually approved the resolution.

For further examples RDF Primer.

But containers only say that certain identified resources are members; they do not say that other members do not exist. There is no way to exclude that there might be another graph somewhere that describes additional members.

RDF Collections
RDF provides support for describing groups containing only the specified members, in the form of RDF collections. An RDF collection is a group of things represented as a list structure in the RDF graph.

in RDF/XML a collection is something like this:

<rdf:Description rdf:about="http://e.org/family/349">      
<s:familyMembers rdf:parseType="Collection">
<rdf:Description rdf:about="http://e.org/person/Paolo"/>
<rdf:Description rdf:about="http://e.org/person/Emanuele"/>
<rdf:Description rdf:about="http://e.org/person/Maria"/>
<rdf:Description rdf:about="http://e.org/person/Franco"/>
</s:familyMembers>
</rdf:Description>

this can also be written in RDF/XML by writing out the same triples (without using rdf:parseType="Collection") using the collection vocabulary:

<rdf:Description rdf:about="http://e.org/family/349">
   <s:familyMembers rdf:nodeID="sch1"/>
</rdf:Description>

<rdf:Description rdf:nodeID="sch1">
   <rdf:first rdf:resource="http://e.org/person/Paolo"/>
   <rdf:rest rdf:nodeID="sch2"/>
</rdf:Description>

<rdf:Description rdf:nodeID="sch2">
   <rdf:first rdf:resource="http://e.org/person/Emanuele"/>
<rdf:rest rdf:nodeID="sch3"/>
</rdf:Description>

<rdf:Description rdf:nodeID="sch3">
   <rdf:first rdf:resource="http://e.org/person/Maria"/>
   <rdf:rest rdf:nodeID="sch4"/>
</rdf:Description>

<rdf:Description rdf:nodeID="sch4">
   <rdf:first rdf:resource="http://e.org/person/Franco"/>
   <rdf:rest rdf:resource=
"http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"/>
</rdf:Description>

For more examples RDF Primer.

RDF imposes no "well-formedness" conditions on the use of the collection vocabulary (it is possible, for instance, to define multiple rdf:first elements), thus, RDF applications that require collections to be well-formed should be written to check that the collection vocabulary is being used appropriately, in order to be fully robust. Maybe OWL which can define additional constraints on the structure of RDF graphs, can rule out some of these cases?

OWL and Ordering
OWL have no support for ordering, but the natural constructs from the underlying RDF vocabulary (rdf:List and rdf:nil) are unavailable in OWL-DL because they are used in its RDF serialization. In principle, rdf:Seq is not illegal but it depends on lexical ordering and has no logical semantics accessible to a DL classifier. In other terms: (1) The elements in a container are defined using the relations rdf:_1, rdf:_2, and so on that have no formal definition in RDF. Using them for the purpose of reasoning will require us to define and enforce the properties of these relations. (2) It is not possible to define a container that has elements only of a specific type. (3) For updating a specific element in a container in a remote source, one is forced to transmit the whole container. (4) It is not possible to associate provenance information with the elements in a container [1].

But OWL has greater expressivity than RDF (with constructs such as transitive properties) and reasoning capabilities (for checking consistency and inferring subsumption). Thus, the idea of reasoning with sequential structures in OWL-DL looks appealing.

[1] Vinay K. Chaudhri, Bill Jarrold, John Pacheco. Exporting Knowledge Bases into OWL. OWL Experiences and Directions (OWLED 2006), Athens, Georgia, USA.

SWAN Ontology v. 1.2 almost ready to go

2008-11-21T21:37:00.006+01:00

In the last months, I've been busy in developing the new version of the ontology [SWAN Ontology] that represents the "backbone" of the SWAN project. In this iteration, I had two major goals in mind: modularity and provenance. The new ontology is composed by a set of modules, actually the SWAN ontology consists of a collection of ontologies. I think this is an important step for several reasons:

first of all the SWAN ontology is growing in size. Modules can help in managing the increasing complexity
modules can improve the learning process of people that want to approach our ontology for modeling scientific discourse or simply for reusing a part of it
defining modules helped me in thinking a little bit more

The architecture of the SWAN ontology release candidate

As additional feature I was also thinking to provide sub-modules for increasing reuse without asking potential users to write their own subset of the SWAN ontology. Thus, for instance, the Agents ontology is split in different modules that can include or not provenance and/or collections. This is because I assume that not everybody wants to deal with the tedious ordered lists and not anybody needs to define provenance the level we need.

Provenance is one of the major aspects in the semantic web world that we are trying to build with SWAN. Our application is mashing up data coming from different sources and we would like to be able to export the new knowledge product giving credit to the original data provider and declaring which piece of software performed the conversion of such data into our format.

I will speak more in detail about provenance in my next post.

[SWAN Ontology] Ciccarese P, Wu E, Kinoshita J, Wong G, Ocana M, Ruttenberg A, Clark T. The SWAN Biomedical Discourse Ontology. Journal of Biomedical Informatics, in press. PMID: 18583197

SWAN - Semantic Web Applications in Neuromedicine [2]

2008-03-05T19:20:00.014+01:00

Thus, SWAN is not a like Wikipedia because several "hypotheses" (consistent or inconsistent) can co-exist. to be more precise I would say that the SWAN ontology is an ontology for modeling scientific discourse. Thus, I would define discourse elements as key entities in the SWAN ecosystem. They represent the hubs of the scientific discourse, or in general of the discourse.

Figure 1 - Walsh Hypothesis in the SWAN browser

Looking at fig. 1 it is possible to see the title of the Hypothesis, a description, the authors of such hypothesis (in this case the authors are the authors of the journal article the hypothesis has been derived from). Then, after the journal article used as source of the informatin related to the hypothesis we have the contained discourse elements. Right, a hypothesis can contain a list of discourse elements. In this case we have a list of claims (scientifically proved discourse elements) but it is possible to have in the discourse elements list other hypothesis, research questions or comments...

The SWAN Team: Tim Clark, June Kinoshita, Paolo Ciccarese, Marco Ocana, Gwen Wong, Elizabeth Wu.

SWAN - Semantic Web Applications in Neuromedicine [1]

2008-03-03T21:16:00.019+01:00

In the last months, Marco and I have been coding for the SWAN project for Mass General Hospital (Neurology Dept) and Harvard Medical School. The SWAN project is the reason I moved to Boston to work. It is not easy to explain in a few words what SWAN (that stands for Semantic Web Applications in Neuromedicine) does (or it is supposed to do). I could say that 'we are using Semantic Web technologies with the idea of helping the researchers' life' but I understand that this is not really useful.

I'll try to explain it better with an example. When I was a student, I used to create summaries of the lessons integrating my notes with what I was finding in some books. I was using obviously (I am not that young anymore) paper sheets, colors, drawings... and so on. I had my formalism for stressing a definition, a theorem a short summary and whatsoever. It was efficient, I could easily remember the things (I have visual memory) and it was faster than going through the book again and again. This was perfect for a single lesson. But what was happening with an entire year of lectures? With different topics somehow connected each others? Well, I tried to update the things but it was hard and everything was getting terribly messy. At that time, the word processors were really poor and crispy. Now we can think of organizing the things in some electronic documents... better we can use a wiki where several students can cooperate to build faster with less effort. Everybody knows wikipedia right? Nice, we have wiki tools, we can decide our formalism, the meaning of the colors... this works if we have "one truth". Let's say I want to create in Wikipedia a page about a politician and I really dislike him/her (something that occurs often to me). I would probably be aggressive and biased. Somebody else could have a different perspective on the same person... this needs a mediation and rules to follow.

Now, the same perspective can be true in science. When we have hypothesis these are still not confirmed facts. Scientists need to prove them and it is normal to have disagreement. Disagreement is part of the scientific process (and as we are not in the Middle Ages we don't risk our life saying something 'different'... I guess). In science disagreement can be a real value.

SWAN is not Wikipedia, it is in some perspective the opposite of it. In SWAN, several 'truths' or better 'hypotheses' (consistent or not) can exist at the same time... inconsistencies can be both declared and inferred (nice uh?). In SWAN we can build the map of science (well, a part of it)... (TO BE CONTINUED)

Classes which are things and classes 'about' things

2008-02-14T21:15:00.006+01:00

One of the most interesting distinctions that I keep always in mind when I create an ontology is what is representing a 'real thing' and what is 'talking about a real thing'. Let's consider an example related to bioinformatics. I want to create an ontology which is modeling proteins. Nowadays there are different sources where we can find information about proteins. If we are building a system performing data integration, we probably don't want to copy all the data belonging to those sources in our knowledge base. It is more correct to build references, sort of records that are pointing to the original source when the user/system wants to know more. What we are building are records, entities that 'talk about' real things like proteins. Vice versa, if we want to provide content about proteins (i.e. providing proteins variants) we would probably model the real things, the actual proteins. It doesn't really make sense to say that a record 'hasVariant' another record. Maybe a record 'refersToVariantRecord' or something like that.

But why all this? Well, this is helping in building the models. Let's say that I want to define a 'authoredBy' property for a scientific article. Now, if I consider the real thing (i.e. the actual article) I can say 'authoredBy' but if i am building a record of the article (a reference like the ones that PubMed does) and I say 'authoredBy' am I referring to the article or to the record? As ontologies are meant to define semantic.... I guess this is a crucial point.

Making ontologies

2008-02-13T20:34:00.004+01:00

In the last years, I have been creating some ontologies for different purposes. When I started, I've been investigating several languages and I ended up to use RDF (Resource Description Framework). Not really for the expressiveness, that is quite limited, but more because it was possible to find more examples about its usage. It is true, specifications have been published by W3C but still, I believe in examples. Thus, I started creating what I would define data schemas in RDF. The idea was simple and the goal was not to use reasoners but to express something semantically. And for simple things it was ok.

But when the ontologies started to grow, I started to feel the need of doing something better defined. And it was time for OWL (Web Ontology Language) and reasoners (at least to check consistency not yet to infer classes). Now, if you are doing a pure ontology definition exercise is fine, but when you have to produce real applications I would say "good luck". First, it is really hard to find good exhaustive examples on owl usage. I mean you can find stuff here and there, but nothing well organized and well described. Sure you have the W3C specifications and document but there's no cookbook nor best practice described out there. Nothing explaining with some examples how to create modular ontologies (ontologies that actually reuse other ontologies not redefining them completely in the very same file) keeping in mind open and close world.

And when you look at online ontologies, you can find all sort of things (meta classes inserted in a hierarchy of real things classes, consistency failures, terms coming from WordNet used as classes in the hierarchy of real things, real things and records with no distinctions). It is really hard to learn out of this.

Young guys are growing...

2007-12-12T17:26:00.000+01:00

On Friday, Bruno Farina and Paolo Mauri are going to take their Master Degree in Computer Science. I'll be present and I have to say that this is a special event for me. I have been mentoring other students before... but the idea that this project become true and available open source is somehow awesome. I am talking about the JDPF project. Paolo and Bruno did a great job and this has been (hoping it is also going to be) a really good learning experience!

JDPF (Java Data Processing Framework)

2007-12-05T10:44:00.001+01:00

JDPF (www.jdpf.org) is a framework for the definition of pipelines/nets for performing data analysis. I've been personally involved many times in the definition of algorithms for doing every sort of data processing (mainly in medical informatics). For this reasons, some time ago, we thought to create something that was able to foster re-usability of data analysis components. And I thought it should have been free, hopefully community driven.

The first implementation, two years ago, has been done from scratch and it was already giving an idea of the power of such an architecture (pipelines are not a news). Recently with the outstanding work of a couple of students (Bruno Farina and Paolo Mauri) and with the valuable help of Ezio Caffi we decided to move to OSGI technology. Working with OSGI has been really interesting and hard at the very beginning (at that time the documentation was really skinny). Now, JDPF is composed by a set of core bundles (that are taking care of net loading, validation and running) and a set of classes that can be used to develop new calculation blocks.

Right, because JDPF is an open architecture upon which you can run your own modules (or re-using the available ones). Let's say for instance that I need to clean some data. I can create my component (right now still editing an xml file, we are going to publish the visual builder soon) putting together the existing modules:

the generator able to load data from a file or location over the internet
the range filter able to clip or simply erase all the data that are outside the specific, allowed range
the serializer that is writing the results in a file

After the creation of the component (or net) we need to edit a second XML-file that is used to parametrize the previous block. For instance we need to define the range for the filtering, how to read the data and where, how to write the data and where.

After the creation of these two xml files JDPF is ready to run on your data... no single line of code has been written by the user.

Of course if you need a new custom block, you need to implement the algorithm. In this case, JDPF helps you in focusing only on that, forgetting the validation and running aspects...

Creating Tabs Programmatically with Dojo 0.9 [2]

2007-09-17T22:14:00.000+02:00

If you had a look of the previous post, you probably saw that it was working. But there was at least an error in there.

<div id="mainTabContainer" dojoType="dijit.layout.TabContainer"
style="float: left; margin-right: 30px; width: 100%;
height: 100%; overflow: hidden">
<div id="tabs"></div>
</div>

I put a div with an id 'tabs'. This is a really bad idea. In fact, even if the tabs are displayed correctly, this is messing up for instance the access by javascript code to those tabs:

for(var i=this.getChildren().length-1; i>=0; i--) {
this.tablist.onCloseButtonClick(this.getChildren()[i]);
}

This code (in my personal tab widget that is an extension of the dojo tab widget - if I will have time I'll post it later), for instance, is not working, as the method getChildren() is returning always and only an element. To get over this problem, instead of declaring a div in the html, I create some divs dynamically, when needed:

var pane1 = new dijit.layout.ContentPane({ id: 'tab1', title: 'Test tab 1' }, dojo.doc.createElement('div'));

and the HTML code will become:

<div id="mainTabContainer" dojoType="dijit.layout.TabContainer"
style="float: left; margin-right: 30px; width: 100%;
height: 100%; overflow: hidden">
</div>

Creating Tabs Programmatically with Dojo 0.9 [1]

2007-09-13T19:21:00.000+02:00

I am in the process of moving one of the projects I am working on from Dojo 4.3 to Dojo 0.9. One of the things I need is to develop an extended version of the dijit.TabContainer. First, I need to be able to create the standard components programmatically.

I created a simple css file like this:

html, body, #main{
width: 100%; /* make the body expand to fill the visible window */
height: 100%;
overflow: hidden; /* erase window level scrollbars */
padding: 0 0 0 0;
margin: 0 0 0 0;
font-family: Verdana,sans-serif;
font-size: 11px;
}

#banner {
width: auto;
float: right;
margin: -1px -4px;
height: 20px;
position: absolute;
z-index: 100;
right: 10px;
top: 6px;
}

And here's the code to be inserted in the html head (pay attention in adjusting the dojo path according to your dojo installation):

<script type="text/javascript" src="../dojo09/dojo/dojo.js"
djConfig="parseOnLoad: true, isDebug: true"></script>
<script type="text/javascript" src="../dojo09/dijit/dijit.js"></script>

<style type="text/css">
@import "../dojo09/dijit/themes/soria/soria.css";
@import "../dojo09/dojo/dojo.css";
@import "css/extTabContainerTest.css";
</style>

The html body:

<body class="soria">
<div id="banner">
<button dojoType="dijit.form.Button" onclick="call_function">
Start Programmatic Test!
</button>
</div>
<div id="mainTabContainer" dojoType="dijit.layout.TabContainer"
style="float: left; margin-right: 30px; width: 100%;
height: 100%; overflow: hidden">
<div id="tabs"></div>
</div>
</body>

Finally the script to be added again in the html head:

<script type="text/javascript">

dojo.require("dojo.parser");
dojo.require("dijit.form.Button");
dojo.require("dijit.layout.ContentPane");
dojo.require("dijit.layout.TabContainer");

function call_function() {

var pane1 = new dijit.layout.ContentPane({ id: 'tab1', title: 'Test tab 1' }, dojo.byId('tabs'));
var pane2 = new dijit.layout.ContentPane({ id: 'tab2', title: 'Test tab 2', closable: true }, dojo.byId('tabs'));

var tabContainer = dijit.byId('mainTabContainer');
tabContainer.addChild(pane1);
tabContainer.addChild(pane2);
}

</script>

Now loading the page and pressing the button on the top right you'll see the two new tabs

Vocabularies for contact details

2007-07-28T19:14:00.000+02:00

Here's a list of vocabularies that can be used to define people/groups/projects details:

FOAF - Friend Of A Friend (Version 0.9 in RDF): it is the most popular vocabulary for representing people and groups details and relationships. One of the things I've always been curious about, is how FOAF models the names (name, given name, first name, family name, surname are all in the vocabulary in 'testing' status). An interesting reading about it can be found in the FOAF wiki. Moreover, FOAF includes also classes such as Project (defined as 'a collective endeavour of some kind' keeping in mind that a project can be not only collective but also individual.. uh?) and Document (which is loosely defined as class that represents those things which are, broadly conceived, 'documents'. An Image is a subclass of Document).
CONTACT (Version 1.13 in RDF) by Tim Berners Lee. I don't know if you can find a 'human readable' resource on it. You probably have to read the rdf file. It is a quite complete vocabulary for defining all contact details of a person. You can find also properties like "nearest airport" or "mother tongue".
VCARD (Version 3.0 in RDF). vCard is defined by RFC 2426 and this RDF representation provides equivalent functionality to its standard format.
DOAP - Description Of A Project (website, rdf).

An invited talk by Prof.Carole Goble on Google Video

2007-02-08T04:42:00.000+01:00

In a recent meeting with Prof. Carole Goble we discovered, that in her keynotes, she's using a screenshot (around minute 12) coming from the prototype of the SWAN (Semantic Web Applications in Neuromedicine) application. Which is the project I am working on now for Mass General Hospital and Harvard Medical School.

Carole Goble is a Professor in the School of Computer Science. She is co-leader of the Information Management Group. She has a leading role in the Semantic Web, e-Science and the Semantic Grid. She applies technical advances in knowledge technologies and workflow systems to solve information management problems for Life Scientists and other scientific disciplines. She was co-PC chair of WWW2006 and is an EIC of the Elsevier’s Journal of Web Semantics.

She is the director of the large UK e-Science my Grid/Taverna programme of work for workflow based middleware for Life Scientists (http://www.mygrid.org.uk). My Grid uses semantic technologies for service and workflow discover and metadata management of workflow-based experiments. My Grid is now part of the Open Middleware Infrastructure Institute UK (http://www.omii.ac.uk); Carole is the chair of this Institute (of 40+ software developers), which has been funded to harden and support developments from the UK’s e-Science programme. She is the co-chair of the Open Grid Forum Semantic Grid Research Group, and the Technical Director of the EU Strep OntoGrid (http://www.ontogrid.net), which has developed the Semantic-Open Grid Service Architecture (S-OGSA) framework for Semantic Grids.

Estonia and Orkut

2005-12-13T14:51:00.000+01:00

Recently I have been to Estonia for a short vacation [1][2]. It is a country of about 1.356.000 citizens located in the north of Europe on the Baltic sea. Well the interesting thing is that Milan (Italy) itself has more inhabitants than whole Estonia and if you look at Orkut community Estonian users are about 0,44% of the total.

It has been written about "Orkut Brazilian invasion" [3], and about Estonia numbers in the same article "orkut has turned most popular in little Eastern-European country Estonia where a little more than 3% (June 2005) of the population are registered orkut users. Brazil holds the second place (about 2.5% of the population in the south east of the country)"

Estonian users are quite the same of Portugal (0.45%) users... but Portugal (more than 10.000.000 inhabitants) is about 8 times Estonia in terms of citizens. And what about Canada? Canada has about 30.000.000 citizens and in orkut it is around 0.53%.

Orkut users from Estonia are usually between the age of 17 and 23... thus, given the whole population [4] we have about 140.000 units in that range. A good part of them is in orkut... interesting...

[1] Fotoalbum
[2] Blog of my trips
[3] Wikipedia
[4] Population distribution in Estonia

Welkin more stylish? [3]

2005-12-03T20:54:00.000+01:00

This is the second developement step for adding in welkin icons to resources of a particular rdf type and to resources with the URI starting with a particular substring (you can download it from svn of the Simile Project).

It is possible to associate an icon to all the resources with the URI starting with a particular substring:

1) Click on the "icons" tab on the left of the welkin interface
2) Type the substring
3) Check the "regexp" checkbox
4) Click on the "Add Element" button

The substring of the new element will be displayed in blue (the "type" element will be in black).

The final result:

Welkin more stylish? [2]

2005-11-27T23:29:00.000+01:00

This is the first developement step for adding in welkin icons to resources of a particular rdf type
(you can find it on svn of the Simile Project)

It is possible to change the icon to be displayed by clicking on the icon image. It is suggested to upload only icons of 16x16 pixels (14x14 maximum) to not have overlapping in the chart.

Clicking on the "trash" icon it is possible to delete one of the defined icon element.

Double clicking on the uri it is possible to modify an already defined icon element.

Welkin more stylish? [1]

2005-11-27T22:14:00.000+01:00

This is the first developement step for adding in welkin icons to resources of a particular rdf type
(you can find it on svn of the Simile Project)

When a model as been loaded it is possible to associate an icon to all the resources of the specified rdf type:

1) Click on the "icons" tab on the left of the welkin interface
2) Type the URI of the desired type to associate to the icon on the left
3) Click on the "Add Element" button

After performing the above steps the new icon element will be displayed on the panel on the top left (4). Enabling the icons drawing (5), the resources that are of the specified type will be displayed with the selected icon (6).

Linotype going to be "semantic"

2005-11-12T02:42:00.000+01:00

Linotype software was written by Stefano Mazzocchi for his own blog [1]. It is implemented as a Cocoon application and the original software is available at [2].

Working on the same software Stefano and I started to introduce semantic annotation of the content through rdf/a [3].

At the location [4] it is available a branch in which an initial integration
of rdf/a is under developement.

[1] http://www.betaversion.org/~stefano/linotype/
[2] http://simile.mit.edu/repository/linotype/trunk/
[3] http://www.w3.org/2001/sw/BestPractices/HTML/2005-rdfa-spec
[4] http://simile.mit.edu/repository/linotype/branches/rdf-a/

Piggy Bank and Solvent... Welcome Semantic Web!

2005-11-04T01:40:00.000+01:00

Three years ago I started my trip through languages and technologies for ontologies definition and usage. I read several papers on this topic and after a certain period I felt quite sad in realizing the high price to pay to obtain a benefit from "semantic add ons".

The idea was to define a sort of perfect micro-world where everything has a well defined meaning. And obviously, after a certain period I gave up. At that time Jena was something really complex to understand to me and Sesame was only a "magic" word. I took a look at the powerful and, in the same time, cryptic KIF formalism, at DAML and DAML+OIL. For some reasons (besically one :D... the serialization in XML was driving me crazy) RDF sounded too weird.

Then OWL came out and I started reading again... n3... Rio... Sesame. The "Semantic Web" concept was still something not well defined and my impression was that OWL was "a light version" of the old-style ontology languages coming from the AI world...

I was wrong, look at the Simile Project... with Piggy Bank and Solvent ... the "semantic web" started to rock!

And now it is clear "Semantic Web" is everything you want it to be ;)