Showing posts from February, 2004

Connecting to Fedora’s X Server

Connecting to Fedora's X Server

Running Fedora and trying to connect to its X server, only to continue to get a can't open display or cannot connect ot display?

Turns out Fedora has TCP connections to its X server disabled by default. I like how they default to more secure, but isn't that what xhost is for?

I am blogging this so that google can push this link up to the top. Hopefully save someone else the time.



We have two standards running parallel with each other; HTML is the de facto standard for document markup, accounting for millions of items on the web. RDF is a standard for expressing metadata, which in turn provides a foundation for making use of that metadata, such as reasoning about it. Yet the former is very rarely the subject of the latter; meta information placed in the HTML family of documents is often encoded in such a way as to make it difficult to extract by RDF-related parsers. And if it cannot be extracted, then it cannot be used.

Our intention here is to make more of the information that is contained within HTML-family documents available to RDF tools, but without putting an unnecessary burden on authors familiar with HTML, but not with the subtleties of triples and statements.

AOP in the Container

JSR 175, JBoss and AOP

Some of the themes echoed by Spring will by found elsewhere. The idea
of the container providing services via AOP is gaining ground. Here is
a brief example of JBoss 4 and it's AOP handling.

Note that Spring can also handle transaction management declared as
metadata right now, though not through xdoclet (spring uses some commons
functionality for reading javadocs). Spring also handles txn declared
in the spring configuration.

VERY cool stuff. J2EE without the EJB!!

SOAP and REST: Round 323523 - Web Services Links

Just bringing back some SOAP and REST discussions and articles. I still have a soft spot for REST.

FOAF Activity

Lost Boy: FOAF Activity

Lots of interesting FOAF activity lately, seemingly spurred on by the ETech presentations.

One thing I'm afraid of w/ FOAF adoption is the same trap RSS 1.0 fell into. All the RSS tools I know of treat RSS as XML instead of a RDF model. This is A Bad Thing for using the data as a RDF graph. If FOAF adoption is to really deliver on its promise, it should be used as a RDF model. Treat it like the graph it's meant to be. FOAF is RDF, it just happens to be serialized as XML. Let's not forget how to interact with RDF!


Metadata Specifications Index Page

Call me jaded, but here's another attempt to solve the problem of link local discovery. You know, since Jini, JXTA, UPnP, Rendezvous, and others did it so horribly. Oh, I know... their downfall was that they didn't use bloated SOAP! Ah ha! Luckily, we now have a discovery protocol that uses XML and SOAP. Can't wait to try to fit all that XML into a single datagram.

I dig XML. But there might be a better way to ask "Is there a printer here?" than a huge SOAP message.

Trust in the SemWeb

Trust and Reputation in Web-based Social Networks

This project is designed to build and maintain a trust network on the semantic web. Using an ontology that extends FOAF, you can assign trust ratings to people you know.


Fabl -- A Native Programming Language for the Semantic Web

A native programming language for the Semantic Web

JDK 1.5 Sample Code

JDK 1.5 Sample Code

JDK 1.5 has some very useful enhancements. Thanks to Josh Bloch of Sun Microsystems for helpful hints.

Lots of great examples of new JDK 1.5 features. Looks like some really useful capabilities.

It’s All About Graphs

Stefano's Linotype ~ It's All About Graphs

The more I discover RDF and RDF query languages, the more itseems to me that it was all about that stupid RDF/XML syntax that prevented people from getting what RDF really was. RDF is a model for describing labelled directed graphs. That's it. You can add typing (RDFSchema) or inference (OWL), but the real deal is that you now have a way to describe graphs.

I always had a hard time explaining RDF to people because everyone saw RDF through XML glasses. I see now that, deep inside, people wanted XML to do what RDF does. That is, describe graphs of information and the relationships between the nodes. Once I got people thinking "RDF is not XML" it was a bit easier.

Approaches to Mocking Approaches to Mocking [Feb. 11, 2004]

Everyone knows what a mock is, just from the name, but as with many seemingly simple ideas, there is more to them than first meets the eye. This article explores the two types of mocks that exist and covers some of the problems inherent in their use. Finally, it considers the reason why a developer might chose to use mocks. After all, common understanding holds that mocks are used for unit testing, a key part of Test Driven Design, but that isn't necessarily about testing at all.

Intro to Extreme Programming

An Introduction to Extreme Programming -- Application Development Programming Extreme Programming

Learn the key practices of Extreme Programming and how this agile development methodology can improve the quality of your code and make your life as a developer more enjoyable.

Why XML 1.1?

xmlhack: Why XML 1.1?

I'd better say it right now, though XML 1.1 and namespaces in XML 1.1 do not include that many changes compared to XML 1.0 and namespaces in XML 1.0, these changes are enough to break the compatibility: a well formed XML 1.1 document isn't necessarily a well formed XML 1.0 document.


SemWebCentral - SemWebCentral Home Page

A site much like freshmeat, but for semantic web applications and tools.

I wonder how much RDF I can get from this site? Can I ask for application/rdf+xml when GETting the home page?

Brief Introduction to IoC

A Brief Introduction to IoC

This article aims to introduce the notion of Inversion Of Control (IoC) and how it can streamline application design. We will look at the different types of IoC frameworks. By showing how IoC can result in simpler, more flexible code, you'll also be able to see why IoC has attracted so much interest of late.

The IoC principle seems to be the cool principle of the week.

W3C Issue RDF and OWL Recommendations

World Wide Web Consortium Issues RDF and OWL Recommendations

Today, the World Wide Web Consortium announced final approval of two key Semantic Web technologies, the revised Resource Description Framework (RDF) and the Web Ontology Language (OWL). RDF and OWL are Semantic Web standards that provide a framework for asset management, enterprise integration and the sharing and reuse of data on the Web. These standard formats for data sharing span application, enterprise, and community boundaries - all of these different types of "user" can share the same information, even if they don't share the same software.

RDF and OWL Testimonials

Testimonials for W3C's Semantic Web Recommendations - RDF and OWL

These testimonials are in support of W3C's Semantic Web Recommendations - RDF and OWL .


StrutsTestCase for JUnit

Doing searching for Mock Testing and In Container Testing, and you'll see a lot of discussion. There are pros and cons to both.

The pro to Mock Testing is that it is quick and you don't need to mess with a container. Long deployment times and constant container restarts make testing in a container a pain.

The pro for In Container testing is that you are actually testing exactly where your code will live. You eliminate some of the variables this way, making a more accurate test environment.

For the sake of speed, though, Mock Testing is the way to go. It's more controllable, too. You can more easily tell when there is an error in your code or the application container.

For testing Struts stuff outside the container, there is Struts Test Case. It also provides implementations of the Servlet classes.

It's pretty slick. With these, the need for writing web tests is greatly diminished.

Representation Web Architecture Review: Representation [Feb. 02, 2004]

Representations of resource states on the Web, as concretized by particular data formats, are meant to be consumed by agents, both human and machine, in a mutually beneficial way. In other words, for any representational system to work, its producers and consumers have to hold in common first and higher-order expectations about their own behavior and about the expectations and behavior of the others.

Automatic Graph Clustering

d2r: social software: automatic relationship clustering

The first thing that the software should be able to do is infer what groups are there, rather than be told what the groups are. With this in hand, if you simply define relationships to your friends, and you take into account their friends and how they relate to you, you should be able to create a graph of probable relationship clusters, that is, groups formed around strong interpersonal relationships. Sounds farfetched? Read on...


GraphPath Language

GraphPath is a little-language for analysing graph-structured data, especially RDF. The syntax of GraphPath is reminiscent of Xpath. It has a python implementation that can be teamed up with your favourite python RDF API (e.g. Redland, rdflib, or your own API).

Mock Objects

Writing simple unit tests is easy (especially with Eclipse). What if your class uses outside resources, such as JDBC connections? You don't want to have a real database connection. That takes too long to setup and is too cumbersome to write quick tests with.

Mock Objects (a good implementation is found at (WORST website in the world)) handles this situation reall well. It allows you to write tests against code that use otherwise heavy weight or expensive dependencies.

Mock Objects are two things. They are implementations of common interfaces, like java.sql.* or This allows them to slip right in where the regular implementations would.

Mock Objects also are programmable. In your tests you instruct (or, for those of us in the biz, you "program") the mock object what to expect and how it will be interacted with. It's best to illustrate this.

Here is a snippet from a unit test that checks JDBC code.

MockConnection2 connection …


OntoJava is a cross compiler that translates ontologies written with Prot

XML 1.1 is W3C Recommendation

Archive of W3C News in 2004

The World Wide Web Consortium today released Extensible Markup Language (XML) 1.1 and Namespaces in XML 1.1 as W3C Recommendations. XML 1.1 addresses Unicode, control character, and line ending issues. Namespaces 1.1 incorporates errata corrections and provides a mechanism to undeclare prefixes.

Sun to Incorporate JXTA Into Its Products

Sun makes room for Jxta | CNET

Sun Microsystems is planning to incorporate software developed through its peer-to-peer computing initiative, Project Jxta, into its commercial software products.

Semantic Web Stack Diagrams

RDF Interest Group IRC Scratchpad

Semantic Web Stack Diagrams

FOAF and Bluetooth Discovery

Edd Dumbill's Weblog: Behind the Times

Here's the results. BlueFOAF is an application that scans your list of friends from your FOAF file and allows you to associate them with nearby discoverable Bluetooth devices. If their device is discoverable you will be shown their name and picture in a buddy list.

This would be cooler if I knew someone with a bluetooth device.

New Redland Release