By: Eliacim Lopes

Yesterday I wrote about how we’ve integrated AusStage with Twitter so that we can use the Mobile Service to collect live audience participation feedback using the Mobile Service. These services are being developed as part of the Aus-e-Stage project, which is part of the larger AusStage project, and are components of the Audience Participation Feedback service.

In this post I’m going to focus on how we’ve integrated AusStage with Short Message Service (SMS) messages. SMS messages are one of the three ways that we plan on gathering feedback which are:

1. Short Message Service – every mobile phone has at least this capability
2. Twitter – users of twitter can provide feedback using Twitter from their smartphone or other mobile device
3. Mobile Web – users of smartphones or other mobile devices can use a website optimised for mobile devices to submit feedback

The components that integrated AusStage with SMS messages are as follows:

1. A Mobile Modem – used to connect to the mobile phone network
2. A script on the AusStage server that interfaces with the modem to send and receive SMS messages
3. The Input Gatherer API of the Mobile Service – processes incoming SMS messages and stores them in the AusStage database

The workflow for processing SMS messages is outlined in the diagram below:

Incoming SMS Message workflow
(Click for larger version)

Importantly the mobile phone number of the audience member is obfuscated using  a cryptographic hash function. In this way no personally identifying information is kept in the AusStage database or in any related log files. By using a hash it is possible to group messages together in order to identify the same audience member has sent in multiple pieces of feedback, however it is not possible to personally identify them.

In the above workflow an exception report is generated when no matching performance can be found in the AusStage database. An exception report can also be generated as a result of an error such as the database not being available. In this case an email is sent which contains a brief message about the error that occurred and a copy of the message and associated metadata. This will provide sufficient information for a member of the AusStage team to take remedial action as required. For example adding the message text and associated metadata in manually once the database becomes available.

Once data is stored in the AusStage database it can be used for things such as data analysis or displayed on a web page that would provide live feedback at the venue using part of the Mobile Service API that is currently under development.

The photo “SMS” was uploaded to Flickr by Eliacim Lopes and used under the terms of a Creative Commons License.

By: Mohammad Jangda

One of the three services that I’m working here at the Aus-e-Stage project, part of the larger AusStage project, is the Audience Participation Feedback service. This service will use mobile technologies to gather feedback from audience participants. For this reason we call it the Mobile Service for short. A key component of this service is using mobile devices to gather feedback from audience participants either during, or  within two hours of the performance finishing.

Feedback will be gathered using three different mechanisms and they are:

1. Short Message Service – every mobile phone has at least this capability
2. Twitter – users of twitter can provide feedback using Twitter from their smartphone or other mobile device
3. Mobile Web – users of smartphones or other mobile devices can use a website optimised for mobile devices to submit feedback

This post will focus on the second feedback mechanism and outline how AusStage is integrated with Twitter.

The key to the integration is the hash tag. In essence hash tags, or hashtags depending on your preference, are defined at the Twitter Fan Wiki as a

community-driven convention for adding additional context and metadata to your tweets. They’re like tags on Flickr, only added inline to your post. You create a hashtag simply by prefixing a word with a hash symbol: #hashtag.

Our system uses hash tags to identify twitter messages, or tweets as they’re known, that are pieces of feedback using hash tags that are associated with our partner organisations.

The integration of AusStage with the Twitter service is achieved using our TwitterGatherer application that I’ve developed. This application is written in Java and uses the tweetStream4J library to access the Twitter Streaming API and the twitter-text-java library to parse messages and retrieve a list of hash tags.

The workflow for the TwitterGatherer application is outlined in the diagram below:

TwitterGatherer Workflow
(Click for larger version)

Importantly no identifying information is stored in either the log files or the AusStage database. The list of changes made to a tweet as a means of de-identifying users is outlined here.

In the above workflow an exception report is generated when no matching performance can be found in the AusStage database. An exception report can also be generated as a result of an error such as the database not being available. In this case the email contains a brief message about the error that occurred and a copy of the log file. This will provide sufficient information for a member of the AusStage team to take remedial action as required. For example adding the message text and associated metadata in manually once the database becomes available.

Importantly at no time in the process is personally identifying information either stored in the log files, the database or in the exception reports.

Once data is stored in the AusStage database it can be used for things such as data analysis or displayed on a web page that would provide live feedback at the venue using part of the Mobile Service API that is currently under development.

The “Audience at Humanities Theatre” photo was uploaded to Flickr by Mohammad Jangda and used under the terms of a Creative Commons License.

By: Matt Stewart

On the weekend of the 28th and 29th of August I was fortunate to be able to attend the first THATCamp in Australia, THATCamp Canberra. It was the first unconference that I’ve ever attended.

I wasn’t sure what to expect but was determined to attend with an open mind and a willingness to participate. I was struck by the similar feelings of the other participants. From the first group meeting where scheduling for the two days occurred through to the individual sessions and the bootcamp sessions as well. There was always a willingness to share, collaborate and discuss, even if discussions got a little passionate during some sessions.

I didn’t realise it at the time but my suggestion of a session on Exploring the Semantic Technologies in the Humanities was to prove a popular session and one that I would need to facilitate. This caught me by surprise and I hope the participants of the session were pleased with the direction that it took.

One of the main themes from the session was a sense that those of us using these types of technologies are all working through similar issues with regards to data formats, selection of ontologies, building our own ontologies and exploring the potentials of the technologies.

During the discussions an interesting link to a paper from 2000 highlighted that many of the issues that we are working through are similar to those of 10 years ago. Showing that while technologies improve and change the underlying questions, assumptions, and goals remain the same. Another useful outcome from this session was the start of a document that listed all of the semantic web projects that we are working on.

During the two days it became clear to me that Twitter was an invaluable tool for backchannel communication. We all used the same hashtag #thatcamp which means that it is possible to group all of our messages together using a service such as Twapper Keeper. My own tweets are an eclectic mix of notes on discussions, thoughts for future consideration, and topics to explore.

The other sessions I attended included:

A session on linked data where one participant discussed a current project to make there data available in a variety of different formats to promote collaboration and sharing in the form of mashups. What was surprising about this project is that they used screen scraping techniques to convert their HTML based website into data available for sharing because it was easier than trying to interface directly with the backend systems.

Some interesting thoughts from this session are:

• OpenSearch could provide a useful means of sharing data and search results with others that may be useful in the AusStage website redevelopment
• It is easy to focus on the data and lose sight of the documentation and other materials that users may require
• Persistent URLs are key to any linked data project as it provides a reliable way for users to build on your dataset by including reliable links to it from their own systems

A session on crowd sourcing data and participation highlighted a number of very interesting projects including

• Invisible Australians – Living under the White Australia Policy
• London Lives – 1690 to 1800 – Crime, Poverty and Social Policy in the Metropolis
• Founders & Survivors – Australian Life Courses in historical context 1803 to 1920

During this session there was a discussion about project scope and managing the desire to have a large project with the reality of resource constraints such as time and money. In this middle of this discussion one of the participants had one of the best quotes of the day namely:

one way to move forward is to narrow, another is to make the idea bigger which opens up bigger possibilities

I finished the day with a session exploring the topic of what a digital humanist needs to know in relation to technology. This session proved to have some of the most lively and passionate discussion of the day and highlighted a number of issues facing digital humanists. Including the issue of managing the needs to use and understand technologies whilst at the same time maintaining focus on the research and those elements that make a researcher a humanist.

The discussion predominantly focused on the issue from a researchers point of view. That is, they have the research skills but not necessarily the technology skills. My own individual focus is the reverse. I have the technology skills but not the research skills. I’m still not sure how to bridge the gap.

The first session I attended on Sunday was on mapping and this session highlighted many of the issues that we’re working through as part of the development for the Mapping Service as part of the Aus-e-Stage project. One thing to keep in mind is that even small datasets, when approached from the perspective of a map, can provide insight and answers to research questions. Not every mapping activity requires large and complex systems.

It was also useful to see that others who have worked on these types of systems have grappled with similar issues to those that we’re working through with our own development.

The final session was nominally on digital space and was a wide ranging discussion. The main themes that I noted in my Twitter Stream included:

• Consideration for the social justice issues in providing services that require the latest smartphones / tablet devices
• The impact that these services have on the way we view the environment around us
• Now that smartphones have GPS capabilities, is it necessary to create an explicit link between the physical and digital worlds using technologies such as QR Codes. Or is location simply enough?
• how do we visualise the virtual space that we create as we move through our lives in both the physical and virtual world?

It was an exhausting and rewarding weekend and one that gave me plenty to think about.

My thanks and congratulations to the organisers of the THATCamp and my thanks also to my fellow participants without whom the experience wouldn’t have been so positive.

The “Parliament House, Canberra, Australia” photo was uploaded to Flickr by Matt Stewart and used under the terms of a Creative Commons License.

By: Dave Mott

As I mentioned in my last post I’m currently working on a Java based application to retrieve messages from Twitter that represent feedback sourced from audience participants. This is an important part of infrastructure for the Mobile Service is under development as part of the Aus-e-Stage project which is in turn part of the larger AusStage project.\

The hash tag in the message is one of the pieces of information that is used to match a message to a performance. To make it easier to extract the hash tags from the messages I’m exploring the use to the twitter-text-java library. More information about the library is available here.

To keep things separate and easy to manage I’ve decided to set aside a directory specifically for compiling and packaging the library so that I can use my already established processes with my own preferred tools for my development.

To do this I undertook the following tasks:

Note: This is not intended as a full procedure. It is rather a list of notes to act as a reminder to me and a prompt to others who may be experiencing similar issues to those that I had.

1. Configuring my System

1. Ensure the git-core package, including dependencies, is installed
2. Ensure the ant1.8 package, including dependencies, is installed

2. Checkout / Clone the twitter-text-java Repository

1. Create a directory to store files related to development
   mkdir mobile-tools
2. Navigate to the newly created directory
   cd mobile-tools
3. Clone the twitter-text-java repository
   git clone http://github.com/mzsanford/twitter-text-java.git
4. A newly created twitter-text-java directory will be created in the mobile-tools directory that contains the repository

3. Checkout / clone the twitter-text-conformance Repository

1. Navigate to the twitter-text-java directory
   cd twitter-text-java
2. Navigate to the test-data directory
   cd test-data
3. Clone the twitter-text-conformance repository
   git clone http://github.com/mzsanford/twitter-text-conformance.git

4. Compile the twitter-text-java code using ant

1. Navigate to the parent twitter-text-java directory
   cd ../../
2. Compile the source code using ant
   ant compile

5. Optionally compile the code and run the tests

At the time of writing the twitter-text-conformance repository contained tests for the ruby implementation that were not supported by the java version of the library. For this reason the tests were skipped in this procedure. To optionally compile the library and execute the tests execute the ant command without any parameters in step 4.2 above.

6. Package the library

1. Ensure you are in the parent twitter-text-java directory
2. Package the library using ant
   ant dist

The library, packaged as a jar file in the dist directory, can now be included in your own development workflow.

The “TwittDroid” image was uploaded to Flickr by Dave Mott and used under the terms of a Creative Commons license.

By: Dave Mott

My attention today has been focussed on the third service that is under development as part of the Aus-e-Stage project which is in turn part of the larger AusStage project. The focus of this third service is to use mobile based technologies to solicit feedback in real time from audience members who are attending, or have just attended, a performance.

The two main mechanisms for soliciting feedback I’m currently focused on are SMS and Twitter messages.

My current task is exploring the way in which we can interact with Twitter in order to retrieve messages, via the Twitter API, that are pieces of feedback for performances that we’re interested in. All of our development to-date has been in the Java programming language and as such I’ve been looking into libraries that I can used to make it easier for my development work. The library I’m starting with the tweetStream4J library by John Crepezzi.

He uses Git for his source code repository and Apache Maven as his build tool. Whereas we’re using Apache Subversion and Apache Ant respectively. All of our source code is hosted as the Aus-e-Stage project on Google Code. To keep things separate and easy to manage I’ve decided to set aside a directory specifically for compiling and packaging the library so that I can use my already established processes with my own preferred tools for my development.

To do this I undertook the following tasks:

Note: This is not intended as a full procedure. It is rather a list of notes to act as a reminder to me and a prompt to others who may be experiencing similar issues to those that I had.

1. Configuring my System

1. Install the git-core package including dependencies
2. Install the maven2 package including dependencies

2. Checkout / Clone the tweetStream4J Repository

1. Create a directory to store files related to development
   mkdir mobile-tools
2. Navigate to the newly created directory
   cd mobile-tools
3. Clone the tweetStream4J repository
   git clone http://github.com/seejohnrun/tweetStream4J.git
4. A newly created tweetStream4J directory will be created in the mobile-tools directory that contains the repository

3. Compile the tweetStream4J code using Maven

1. Navigate to the newly created tweetStream4J directory
   cd tweetStream4J
2. Compile the source code using Maven
   mvn compile
3. All of the required dependencies will be automatically downloaded into the ~/.m2/repository directory
4. The compiled classes will be in the ./target directory

4. Edit the Tests in preparation for packaging

1. Stay in the tweetStream4J directory
2. Navigate to the following directory
   ./src/test/java/com/crepezzi/tweetStream4j
3. Open the following file for editing
   ./APITest.java
4. Locate the following line
   

   private static final TwitterStreamConfiguration tws = new TwitterStreamConfiguration("seejohnrun", "");
   

5. Change the line so that it includes your Twitter username and password. For example:

   private static final TwitterStreamConfiguration tws = new TwitterStreamConfiguration("myuser", "mypass");
   

6. Save the changed file

5. Package the tweetStream4J code using Maven

1. Navigate to the main tweetStream4J directory
   cd ../../../../../../
2. Package the compiled classes using Maven
   mvn package
3. All of the required dependencies will be automatically downloaded into the ~/.m2/repository directory
4. The packaged jar file will be in the ./target directory

6. Use the Packaged tweetStream4J Library

1. Copy the packaged library to the required location
2. Ensure the other required dependencies are in your class path or in the same location as the library
3. At the time of writing the list included:
   • JSON-LIB 2.3
   • EZMorph 1.0.6
   • Commons – BeanUtils
   • Commons – Lang
   • Commons – Collections
   • Commons – Logging

7. Keeping the Source Code Updated

1. Navigate to the mobile-tools directory
2. Navigate to the tweetStream4J directory
   cd tweetStream4J
3. Update the source code with the following command
   git pull
4. Repeat steps 4 and 5 above to recompile and package the library

The “Twitter Bling” image was uploaded to Flickr by Dave Mott and used under the terms of a Creative Commons License.

By: Deborah Herbaut

My focus in the past few weeks, as evidenced by the posts on this blog, has been the construction of an RDF based datastore for use in the development of the Navigating Networks service as part of the Aus-e-Stage project which is part of the larger AusStage project. In particular I’m using Java with the Jena, TDB and related libraries.

The RDF based datastore contains a subset of the data available in the AusStage database specifically targeting those fields and relationships needed to meet the required of the Navigating Networks service as outlined in the Service Specification. Its best to think of it as an alternative index and supplementary datastore. The AusStage relational database remains the primary source of data.

Access to data in the datastore will be made possible via two mechanisms.

The first is under development and will be an API that simplifies access to well defined datasets. One of the first datasets under investigation is known as Key collaborators with a related dataset known as Key organisations. The main aim is to provide a mechanism whereby a URL can be constructed that will query that datastore and return the required dataset. Similar to the way the Data Exchange Service currently works.

The second is currently available for testing, is best thought of as experimental at this stage, and is a SPARQL endpoint powered by the Joseki SPARQL server. The intention behind providing a SPARQL endpoint is to allow ad-hoc querying of the dataset in ways that is not supported by the API. If a certain query, or style of query, is found to be useful it will be included in the API. More information about the service is available on our wiki as is a few sample queries. If you plan on using the service it is best to become familiar with the fields and prefixes used in the construction of the datastore.

The photo “Sparkle in Spring” was uploaded to Flickr by Deborah Herbaut and used under the terms of a Creative Commons license.

By: Andrew Mason

My most recent posts have been about my explorations into ways to resolve a memory resource issue I was having with some code I was developing for the Navigating Networks service as part of the Aus-e-Stage project which is part of the larger AusStage project. In particular I was Exploring the Java Heap as a way to determine what was happening in my app which caused it to run out of memory.

Using some advice I got from the jena-dev group I started investigating the VisualVM tool. If you’ve read any of my posts before you’ll know that I use Ubuntu as my primary operating system on all of my machines including my workstation here at work.

When I first started investigating VisualVM I tried to run it from the command line and got a command not found error with a suggestion that it would be available as part of the visualvm package. Unfortunately on the 64bit version of Ubuntu the package has a bug and it is missing a file.

My Java development requires me to use the proprietary version of Java available in the sun-java6-* packages in the Ubuntu Partner repository. Using these packages the VisualVM application is installed it just isn’t available in the default path which means it can’t be found when you try to run it from outside the directory that it is in.

On my system VisualVM is located here:

/usr/lib/jvm/java-6-sun/bin/jvisualvm

To be able to run it from anywhere I created a link to it using the ln tool in the /usr/bin directory like this:

cd /usr/bin
sudo ln -s /usr/lib/jvm/java-6-sun/bin/jvisualvm ./jvisualvm

With the link in place the app can be found in the default path and I can execute it from the command line from anywhere.

The “Magnifying the Circuit Board” photo was uploaded to Flickr by Andrew Mason and used under the terms of a Creative Commons license.

By: Daniel Dionne

Yesterday I wrote about the explorations I’ve been undertaking with Jena, TDB, Memory Issues and AusStage. In that post I noted that there was a sharp drop in the amount of heap that was being used during the execution of the code that adds the collaboration relationships to the dataset. I was thinking about this sharp drop last night and wondering what caused it.

The way that data is added to the RDF based dataset is as follows:

1. An SQL statement executed against the AusStage database
2. The set of records returned from the database is iterated over
3. Each record is used to construct the appropriate RDF resources and properties
4. Once all records have been processed the SQL related objects are closed

Importantly these steps occur for each stage of the export process and are enclosed on their own try / catch block. I started wondering if there was something happening inside the try / catch block that was consuming resources on the heap that would only release the memory once the program had moved to the next try / catch block.

Inside the while loop that processes the records I had code that repeatedly defined variables that were used for a short time and then not used again.

//start of a contrived example

while (resultSet.next()) {
  String firstVariable  = resultSet.getString(1);
  String secondVariable = resultSet.getString(2);
  // do something with the variables
}

I made a change to the code this morning whereby all variables using inside the while loop were defined outside the while loop and then had values assigned as necessary inside the while loop. For example the code now looks like this:

//start of a contrived example
String firstVariable  = null;
String secondVariable = null;

while  (resultSet.next()) {
  firstVariable  = resultSet.getString(1);
  secondVariable = resultSet.getString(2);
  // do something with the variables
}

Running the updated program and watching the heap usage using the VisualVM application I could see that a lot of the heap was still being used. However, significantly it was less than the amount used before the change by about 250MB.

What this suggests to me is that the second way of implementing the code uses less of the heap and that this can only be a good thing for my application. Especially as it still uses quite a lot of memory due to the caching that the Jena and TDB libraries do.

Later this morning I’ll be going over the rest of the code and ensuring that the other loops are implemented using the same technique.

The photo “Getting some RAM installed” was uploaded to Flickr by Daniel Dionne and used under the terms of a Creative Commons license.

By: t0msk

The past week or so has seen me continuing my work on exporting a subset of the AusStage dataset into an RDF based datastore using Jena and TDB for the Navigating Networks Service. It’s been a frustrating time as I’ve been working my way through issues related to memory management and garbage collection in Java.

My essential problem was that I kept running out of memory that my application could use. More specifically I was running out of heap space. The purpose of this post is to reflect on some of the lessons that I’ve learned so far.

My first way of reducing the amount of memory required by my application was to switch from using Java Collections to the manage a set of Jena Resource objects. I maintain this list to ensure that any subsequent data that I add to the datastore relates to a contributor that I’ve already processed.

This is necessary because updates to the AusStage data can, and do, happen at any time. To reduce the amount of memory consumed by my application I’ve switched to maintaining a set of integers, representing the unique identifiers or contributors, using the GNU Trove library. Rather than store Jena Resource objects I use the Model.createResource() method to create new resources and return instances of resources that have already been added to the RDF model.

I also optimised my SQL queries to return the exact datasets that I require, and with the assistance of one of my colleagues use SQL to de-duplicate the list of relationships between contributors. Trying to do this in my Java code was causing too much memory to be consumed.

Lastly, after sending a few messages to the Jena-dev mailing list I tweaked some other aspects of the code and gained a great understanding of what was happening. Many thanks to those who responded.

All of this means that my code now successfully runs again, but this is not to say that it doesn’t require a large amount of memory. As can be seen from the instructions for the RdfExport application stored in our Wiki on the Aus-e-Stage project pages the application does require 2 gigabytes of heap space. This necessitated moving to the 64-bit version of Ubuntu and away from the 32-bit version so that I could use the 64bit version of the Java Virtual Machine.

The majority of this space is used when collaborations, the resources representing a collaboration between two contributors, are added to the datastore. At the moment there are in excess of 1.6 million unique collaborations represented in the AusStage database. An attribute of a collaboration resource is how many times the two contributors have collaborated together has occurred. This means that the actual number of times that two contributors have worked together is significantly more than this.

Using the VisualVM application as suggested by a message posted to the mailing list I can see when my code starts to add collaborations and the impact this has on heap space.

Heap Allocation Graph (Click Image for Larger Version)

On the right hand side you can see how the amount of allocated heap space and the amount of heap used increases as the collaboration resources are added. Once all of the resources are added the heap space usage drops off to just under half of the maximum. Without the 2GB of heap space my application would fail with an out of memory error related to the garbage collector spending too much time undertaking garbage collection for little or no heap recovery. This error was usually prefaced with my application slowing to a crawl with what I assume is more and more time spent by the JVM trying to do garbage collection.

The -XX:-UseGCOverheadLimit option was not helpful in this instance as it just prolonged the inevitable.

[Update Monday 19 July 2010]

I forgot to mention that the final change I made to my code was to develop and run it on 64bit operating systems. This is because of the 1.5 – 1.6GB heap space limit that the 32bit version of the JVM has.

[/Update]

By undertaking these changes my application now compiles the dataset using the fields that are currently required. Further changes will need to be made to add some additional fields and manipulate other aspects of the data for use by the Navigating Networks Service.

Some interesting statistics of the current dataset are:

• 81,680 contributors resources
• 101,984 contributor function properties
• 1,640,250 collaboration resources
• 43,706 event resources
• 283,617 contributor functions at events

In total there are 15,924,406 triples in the datastore.

The photo “244/365 Six Rocks” photos was uploaded to Flickr by t0msk and used under the terms of a Creative Commons License.

By: Proggie

My last few posts have focused on my use of Jena as a means of constructing a RDF based dataset using data sourced from the AusStage relational database for use with the Navigating Networks component of the Aus-e-Stage project. I’m taking this approach for two main reasons:

1. It is faster to query than the relational database
2. It gives us experience in using RDF and related technologies for use in other aspects of the AusStage project

One of the primary key components of the dataset is the relationships between contributors. A contributor is someone who has in some way contributed to an event. A relationship is deemed to exist where two contributors have contributed to the same event. For the purposes of this discussion I’m calling this a collaboration.

We use the FOAF ontology to store basic biographical information about contributors and we were using the foaf:knows term to model the relationships between contributors. Continued development of the Networking Service Goals and the Networking Service Specification have shown that the foaf:knows term isn’t sufficient to model the complex data related to a collaboration. One of the properties of interest is the number of times that two contributors have collaborated on the same event and the FOAF ontology doesn’t provide a mechanism for modelling this type of information.

In conjunction with the development of the dataset I’ve been working on the basis of an Aus-e-Stage ontology. This ontology allows me to model the data required for the Navigating Networks service where existing ontologies are not available.

Please Note that this ontology is only meant as a stopgap measure and should in no way be seen as pre-empting the work that will be conducted as part of another AusStage related project in flattening the entire AusStage dataset for periodic export into a data repository.

The ontology provides four terms related to collaborations which are:

1. collaboration – used to store details of a collaboration relationship
2. collaborator -  a reference to a contributor involved in this collaboration (appears twice, one for each contributor)
3. collaborationCount – the number of times the two contributors have collaborated
4. hasCollaboration – stores a reference to a collaboration with a contributor

An example of two contributors and their collaboration is shown in the following snippet of Notation3 code below.

@prefix time:    <http://www.w3.org/2006/time#> .
@prefix tl:      <http://purl.org/NET/c4dm/timeline.owl#> .
@prefix foaf:    <http://xmlns.com/foaf/0.1/> .
@prefix event:   <http://purl.org/NET/c4dm/event.owl#> .
@prefix xsd:     <http://www.w3.org/2001/XMLSchema> .
@prefix ausestage:  <http://code.google.com/p/aus-e-stage/wiki/AuseStageOntology#> .
@prefix dcterms:  <http://purl.org/dc/terms/> .

<ausstage:c:261085>
      a       foaf:Person ;
      ausestage:collaboratorCount
              "17" ;
      ausestage:function "Circus Style Performer" ;
      ausestage:hasCollaboration
              <ausstage:rel:261085-261086> ;
      ausestage:nationality
              "Australian" ;
      foaf:familyName "Ristic" ;
      foaf:givenName "Denjan" ;
      foaf:name "Denjan Ristic" ;
      foaf:page "http://www.ausstage.edu.au/indexdrilldown.jsp?xcid=59&f_contrib_id=261085" .

<ausstage:c:261086>
      a       foaf:Person ;
      ausestage:collaboratorCount
              "17" ;
      ausestage:function "Circus Style Performer" ;
      ausestage:hasCollaboration
              <ausstage:rel:261085-261086> ;
      ausestage:nationality
              "Australian" ;
      foaf:familyName "Sanders" ;
      foaf:givenName "D'Nash" ;
      foaf:name "D'Nash Sanders" ;
      foaf:page "http://www.ausstage.edu.au/indexdrilldown.jsp?xcid=59&f_contrib_id=261086" .

<ausstage:rel:261085-261086>
      a       ausestage:collaboration ;
      ausestage:collaborationCount
              "1" ;
      ausestage:collaborator
              <ausstage:c:261085> , <ausstage:c:261086> .

In the above code there is:

• A foaf:person with the unique identifier ausstage:c:261085
• A second foaf:person with the unique identifier ausstage:c:261086
• A ausestage:collaboration linked to the contributors

The unique identifiers are encoded using this URI scheme which provides a way to easily distinguish between identifiers that are used for contributors, events, and other internal objects such as these collaboration relationships.

Using this type of model to record collaborations is extensible and additional information can be included. One data element that is of particular interest is the time span of the collaboration relationship as determined by the dates associated by the events that form the collaboration. For example if the first event that was part of the collaboration started on 01/01/2010 and the last event finish on 01/06/2010 it could be said that the collaboration relationship lasted 6 months.

The dataset, and by extension the data model, continue to evolve as more is understood about RDF and the supporting technologies as well as the continued development of the Navigating Networks Service goals and specification.

The photo “Contortion” was uploaded to Flickr by Proggie and used under the terms of a Creative Commons license.