Posts

Showing posts from January, 2006

Embedding RDF into XHTML

RDF/A Primer 1.0 is an effort to allow embedding RDF into XHTML. To me, this problem of "How do I get my RDF into my web pages?" is only second to creating a friendly RDF XML format. Solve these two problems and you'll immediately see a greater adoption of semantic web technologies.

> RDF/A is a set of attributes used to embed RDF in XHTML. An important goal of RDF/A is to achieve this RDF embedding without repeating existing XHTML content when that content is the metadata. Though RDF/A was initially designed for XHTML2, one should be able to use RDF/A with other XML dialects, e.g. XHTML1, SVG, given proper schema additions.

From what I could see, this is a simple way to add more semantics to your web page. It doesn't appear that the authors explicitly mention how to get the semantics out of the document, though. However, I've never been too fond on GRDDL and it's use of XSLT so hopefully RDF/A will provide an easier metadata extraction technigue.

Google’s BigTable

Andrew’s Website has a very interesting writeup on Google's BigTable, their system for storing large amounts of data in a semi-structured manner.

> BigTable has been in development since early 2004 and has been in active use for about eight months (about February 2005). There are currently around 100 cells for services such as Print, Search History, Maps, and Orkut. Following Google's philosophy, BigTable was an in-house development designed to run on commodity hardware. BigTable allows Google to have a very small incremental cost for new services and expanded computing power (they don't have to buy a license for every machine, for example). BigTable is built atop their other services, specifically GFS, Scheduler, Lock Service, and MapReduce.

There's some audio available, too.

Java.net App Hosting

Hong Zhang's Blog mentions that java.net is now hosting J2EE applications for free through LocalWeb. Here's the quote that scares me:

> The actual deployment of an application is done by a small team of engineers from Sun.

Yikes. Even with all the deployment descriptors, it takes "a small team" to host and deploy a single J2EE application. There's something wrong with that.

I've always said that deploying Java applications is Java's Achilles Heel. The LAMP community mocks Java not necessarily because the language is more verbose, but because it's so dang hard to deploy the applications. Compare with PHP, which is as easy as editing the file and then hitting reload in your browser. That's nearly impossible with a full J2EE application. So many libraries have memory leaks that play havoc with classloaders that a full application server restart is required.

In any case, this is one of the main reasons I've been moving to Rails. I can deplo…

Waterfall 2006 - International Conference on Sequential Development

Waterfall 2006 - International Conference on Sequential Development

> After years of being disparaged by some in the software development community, the waterfall process is back with a vengeance. You've always known a good waterfall-based process is the right way to develop software projects. Come to the Waterfall 2006 conference and see how a sequential development process can benefit your next project. Learn how slow, deliberate handoffs (with signatures!) between groups can slow the rate of change on any project so that development teams have more time to spend on anticipating user needs through big, upfront design.

This is a must-attend conference. Don't miss sessions like wordUnit: A Document Testing Framework and Introduction to Dogmatic Programming.

Trend Lines and Regression Lines

Regression: Fitting Functions to Data shows us how to create trend lines, or regression lines. These lines are very popular in graphs, helping to visualize the trend of the data.

> ...we see how to obtain a linear or exponential model from two data points: we only need to find the equation of the line or exponential curve passing through them. However, it often happens that we have many data points that don't quite all lie on one line or exponential curve. The problem then is to find the line, exponential curve, quadratic curve, or what have you coming closest to passing through all of the points. the relationship between price and demand, or cost. In this interactive module, we discuss how we can come up with such a model.

Web 2.0 Validator

The Web 2.0 Validator tells you just how cool your web site is.

> The validator came to life as the result of some goofing around, and was primarily intended to provide some amusement. But the implementation is itslef an exploration into some of the themes that seem to pop up around the Web 2.0 meme.

Using simple rules like "Does the site mention Ruby?" and "Does the site use AJAX?", this validator will give your web site a score based on how Web 2.0 it is.

The rules for Web 2.0 compliance are written by the community, using simple bookmarks on del.icio.us. Now that is Web 2.0.

SPARQL Protocol

> SPARQL is a query language and protocol for RDF. This document specifies the SPARQL Protocol; it uses WSDL 2.0 to describe a means for conveying SPARQL queries to an SPARQL query processing service and returning the query results to the entity that requested them.

Of interest is that there are HTTP bindings specifically mentioned in the WSDL 2.0 document.

Developers Guide to Semantic Web Toolkits for different Programming Languages

Developers Guide to Semantic Web Toolkits for different Programming Languages

> This guide collects Semantic Web toolkits for different programming languages and gives an overview about the features of each toolkit, the strength of the development effort and the toolkit's user community.

EulerMoz - Inference Engine in Javascript

EulerMoz is an inference engine written in Javascript. Based on the original Euler proof mechanism.

> EulerMoz is an inference engine supporting logic based proofs based on EulerSharp project.

Internationalize Rails

Globalize

> Globalize is a Ruby on Rails plugin designed to support multilingual applications. It’s under the MIT License, same as Ruby on Rails.

Ontology Driven Architectures and Potential Uses of the Semantic Web in Systems and Software Engineering

Ontology Driven Architectures and Potential Uses of the Semantic Web in Systems and Software Engineering

Wow, I was just asking about software engineering concerns specific to the semantic web, and here we go.

> This note outlines the benefits of applying knowledge representation languages common to the Semantic Web, such as RDF and OWL, in Systems and Software Engineering practices.

A resolution for well-being

A resolution for well-being

> The reduction in mortality from coronary artery disease is the same if not better with lifestyle or dietary changes as it is with medications. Other things to consider (but not analyzed in this study) are that lifestyle changes, such as more physical activity, don't produce bad side effects -- well, maybe a little sweat, but all medications may have some side effects. And certainly the cost of exercise vs. medication is lower too.

More proof that simple moderation and exercise is all that's needed nearly all the time.

FreeNAS: The Free NAS Server

FreeNAS: The Free NAS Server

> FreeNAS is a free NAS (Network-Attached Storage) server, supporting: CIFS (samba), FTP, NFS protocols, Software RAID (0,1,5) with a Full WEB configuration interface. FreeNAS takes less than 16MB once installed on Compact Flash, hard drive or USB key.

I just bought a SimpleTech SimpleShare, but this looks like a really nice and complete project.

On the Quality of Metadata…

Stefano's Linotype ~ On the Quality of Metadata...

> One thing we figured out a while ago is that merging two (or more) datasets with high quality metadata results in a new dataset with much lower quality metadata. The "measure" of this quality is just subjective and perceptual, but it's a constant thing: everytime we showed this to people that cared about the data more than the software we were writing, they could not understand why we were so excited about such a system, where clearly the data was so much poorer than what they were expecting.

RDF Queries and Ontologies

Danny nicely puts the problem I'm trying to solve in his post titled SPARQL trick #23. He says:

> Running inference on the store’s data as a whole may be expensive, but without it many results for a given query may be missed.

This is exactly why we are attracted to semantic web technologies. I have a lot of data, but I know there are many more pieces of information in there if I can apply some ontologies and rules. My queries against the system must search both the raw triples I have plus any triples that can be inferred by my ontologies. To me, this is one of the main value adds of the system.

The other main value add of a RDF store vs. a traditional relational store is that it's much easier and cheaper to say arbitrary things. In a relational store, your schema must be defined up front, severly limiting your ability to define data in the future. With RDF, saying anything about anything is cheap.

There are some solutions that work well for data sets that are static. You…

OWL Inference Engine in Jess

OWL Inference Engine in Jess

> This page contains source code and instructions to load OWL ontologies and annotations into a JESS knowledge base

Best Reasoner Available?

We have some applications that are screaming out for a semantic web solution. I'm having a hard time finding the right tools to put together a demo to convince management this is the way to go.

Oracle 10g seems to have the best RDF storage engine around. We license and use Oracle heavily, so this isn't a problem.

The real selling point is the inferencer or reasoner. I haven't found a good, solid OWL and rules reasoner out there. Certainly nothing that can scale to the millions of triples, which any application we build would require (at a minimum).

This leads me to wonder if a good semantic web application should even expect to use an inferencer. The larger question here is, What is the tool stack and information process flow for a semantic web application?

For traditional relational applications, this is well known. For instance, you need a database, some sort of object/relational mapping layer, and a set of classes that implement your business logic. The key here is t…

Understanding Migrations in Ruby on Rails

UnderstandingMigrations in Ruby on Rails

> ActiveRecordMigration allow you to use Ruby to define changes to your database schema, making it possible to use a version control system to keep things synchronised with the actual code.

A Bit of DRYness for Unit Tests in Rails

A Bit of DRYness for Unit Tests in Rails

> After spending way too much time writing these nearly identical tests over and over again for each of my test cases, I finally got around to refactoring the idiom out into a couple of class methods on Test::Unit::TestCase itself.

Simplify your Rails Unit Tests

Simplify your Rails Unit Tests

> So you’ve spent a few weeks writing your Ruby on Rails application, and then you realize you’ve been spending all of your time learning about this awesome language and web development framework, and all of the automagically generated unit tests that Rails makes for you are really just stubs. Damn. You sit down and start coding, but you realize you’re writing variations on a theme: check to see if a model creates/updates/destroys correctly, etc. etc. You remember something DHH said about a TLA… that’s right! DRY!

The 29 Healthiest Foods on the Planet

The 29 Healthiest Foods on the Planet

> The following is a "healthy food hot list" consisting of the 29 food that will give you the biggest nutritional bang for you caloric buck, as well as decrease your risk for deadly illnesses like cancer, diabetes and heart disease.

Sudoku in OWL

Sudoku in OWL

> To demonstrate how a Sudoku Puzzle can be represented in OWL and then solved using an OWL-DL reasoner, we consider a simple example. The Sudoku grid below is of dimensions 4 X 4, and has four sub-grids each of dimension 2 X 2. The numbers in bold are known beforehand (i.e., represent inputs) to the puzzle.

Spring 2.0 Auto View Name Generation

Spring 2.0 will have support for autogenerating view names from a request. Rob Harrop has checked in this new strategy interface, reducing the amount of configuration required when writing Spring MVC applications.



/**
* Strategy interface used to translate an incoming {@link javax.servlet.http.HttpServletRequest}
* into a view name when no view name is supplied by the user.
*
* @author Rob Harrop
* @since 2.0M2
*/
public interface RequestToViewNameTranslator {

/**
* Translate the incoming {@link HttpServletRequest} into a view name.
* Cannot return null.
*/
String translate(HttpServletRequest request);
}



This is largely added in order to simplify working with Spring MVC.

Spring 2.0 Gets Scripting Support

It looks like Rob Harrop is now moving scripting into the main tree with support for Groovy, BSF and JRuby.

Spring, meet Ruby.

Tag Ontology

The Tag Ontology contains

> The goal of this ontology is to model the relationship between an agent, an arbitrary resource, and one or more tags. This relationship is embodied in one or more taggings, which are temporal events associating the actors.

Spring 2.0 Schema Files Online

The Spring 2.0 XML Schema files are now online. These include the specialized schemas for Spring 2.0's custom tags:

[http://www.springframework.org/schema/aop/spring-aop.xsd](http://www.springframework.org/schema/aop/spring-aop.xsd)
[http://www.springframework.org/schema/beans/spring-beans.xsd](http://www.springframework.org/schema/beans/spring-beans.xsd)
[http://www.springframework.org/schema/jndi/spring-jndi.xsd](http://www.springframework.org/schema/jndi/spring-jndi.xsd)
[http://www.springframework.org/schema/tx/spring-tx.xsd](http://www.springframework.org/schema/tx/spring-tx.xsd)
[http://www.springframework.org/schema/util/spring-util.xsd](http://www.springframework.org/schema/util/spring-util.xsd)

Ajax Patterns

Ajax Patterns contains lots of helpful usage patterns for AJAX applications.

> Welcome to AjaxPatterns.org, an Ajax portal and homepage for the upcoming "Ajax Design Patterns" book (O'Reilly), with full text online. Maintained by Michael Mahemoff.

Real Lessons for Rails Deployment

James Duncan Davidson has written up some Real Lessons for Rails Deployment. With the introduction of Switchtower, deploying with Rails is a piece of cake. Read on...

> It's these lessons that I want to share with you on this Christmas Eve. I know that some of you will want me to just to say "Hey, here's how you do it when you need xyz...". And, I'll get to those in later essays (this one is already too long at over 2500 words). But for now, the lessons. Later, we'll get to the recipes.

Freezing your Rails when you deploy shared

Freezing your Rails when you deploy shared applications in order to protect your app from changes made by the hosting company.

> If you’re running a Ruby on Rails application on a shared host, it’s super-double-plus recommended to freeze your Rails. Freezing your Rails means putting the framework into vendor/rails instead of floating with whatever gems that are installed on the host. Because if you do so, you’ll automatically be upgraded when they are. Not a great thing for a production application to have forced upon itself.

> The great news is that this is silly simple. If you’re running 0.14.x or newer, you can simple do rake freeze_gems, and the current gems the system is used are unpacked into vendor/rails. Now the host can update as silly as it wants without affecting your application.

Spring based Application Server

Abstract Horizon has released the Spring Application Server, which is:

> Spring Application Server is simple, highly configurable and light-weight application container based on Spring Framework. Server components are POJOs defined under the Spring Framework that is extended to provide support for services.

The interesting part is its use of Modules, a concept that Spring doesn't quite have yet.

> The server is organised around Modules. Each module describes an unit that exists within a server's boundaries. The modules are organised in a hierarcy of dependancies.