Stayed up way too late last night, but I finally got a first alpha release of FXRuby 1.2 out the door. After testing the waters on the mailing list, I decided to go ahead with my plan to switch to a RubyGems-based distribution of the code. It took some work to make this transition, and I’m still not sure that the gems are quite right, but it feels like the right decision for the long term. I finally got the files released to SourceForge, tagged it in CVS and then sent out the e-mail announcement to the FXRuby mailing lists.

As Murphy’s Law would have it, the SourceForge mailing list services went down around that time and so no one has actually seen those announcements yet.

I somehow missed this last week, but child poet Mattie Stepanek passed away on Tuesday, June 22. He was thirteen years old. According to the story at CNN.com, he died due to complications from dysautonomic mitochondrial myopathy, a genetic disease that impaired his heart rate, breathing, blood pressure and digestion, and caused muscle weakness.

Denise and I learned about Mattie a few years back when his books started to gain national attention. Now, I’m no poetry critic and I couldn’t tell you if his poetry was actually any good. The thing that impressed me about this kid was his optimistic spirit in the face of what I would consider a pretty miserable existence. Mattie was wheelchair-bound and relied on a feeding tube, a ventilator and frequent blood transfusions to stay alive. Three of his older siblings had died of the same disease that eventually claimed his own life, and he surely understood what that meant for his own life expectancy. Despite all this, he remained upbeat and hopeful. My impression, based on a handful of his television interviews, is that he was an unusually mature and thoughtful young man who inspired a lot of people with his words.

chromatic at the O’Reilly Network has published his interview with Andy and Dave. They covered several topics near and dear to the Pragmatic Programmers’ hearts, including the self-published Pragmatic Bookshelf titles and the need for continuous learning on the part of pragmatic software developers, but the point which especially hit home with me was their call to “cut the clutter” and reduce the growing complexity in software development.

J2EE application development was singled out, and is surely the poster boy for runaway frameworks, but I think the problem’s evident in a lot of the latest technologies. My first question after looking at the state of the W3C’s Semantic Web project, and specifically the now-official OWL specification, was, “Who is it that actually needs this level of complexity?” In a widely-discussed article from last November, Clay Shirky observed that “… the Semantic Web imagines that completeness and correctness of data exposed on the web are the cardinal virtues, and that any amount of implementation complexity is acceptable in pursuit of those virtues.” I’m curious to see how (or if) all of the effort expended in developing standards like OWL (and the growing number of OWL-based ontologies) will lead to useful applications in the coming years.

The first post-FOX 1.2 release of the “What’s New in FOX 1.2″ is now available for viewing. A PDF version of the same is available here.

CNET is reporting that the Comdex computer trade show has been cancelled for 2004. Apparently attendance has been dropping off for several years.

I remember getting passes to Comdex once when it was held in Atlanta. This was probably in the late eighties or early nineties; I know that I was still in college. We ate lunch at a Houston’s steak house and of course loaded up on a lot of free stuff at the show. It’s funny to see this story today because I recently discovered an “I’m Sticking With DOS” button that I must have picked up at a Digital Research booth, back when DR-DOS still existed.

I noticed a new problem after the most recent release of FXRuby. It turns out that due to a recent “fix”, text in the release notes for a given file release is no longer rendered as HTML; it is instead escaped, making any HTML in the release notes basically incomprehensible. This change of course applies “retroactively,” in the sense that if you were to now go back and look at the release notes for an older release, they’ll look like garbage too (see, for example, the borked change notes for FXRuby version 1.0.28).

There’s no way that I’m going to go back and sanitize all of the old releases’ release notes to use plain text and not HTML. And, to be honest, I don’t know if anyone was actually reading those anyways, since I usually refer people directly to the change notes at the home page. But it’s the principle of the thing.

When I went looking for some mention of this change, somewhere in the SourceForge site documentation, the only thing I could find was this SourceForge support request from Helge Schulz. In his support request, Helge politely described the problems associated with this change and suggested a way that SourceForge could alleviate the problem for projects whose release notes use HTML. Here is the terse response from David Burley, the SourceForge Support Tech who responded to the support request:

“HTML was never intended to work in the release notes (the fact that it worked was a bug in and of itself).”

Perhaps so, but this “bug” went unnoticed by users for years because it was, in fact, a useful feature of the file release system. This is an excellent illustration of the dark side of “Works as Designed”.

For this brief moment during which I think I get it:

• the range of a property indicates the type(s) of values it can take on. For example, foaf:homepage has the range foaf:Document, because your homepage must be a Document resource. Another way to say this is that “foaf:Document is the range of foaf:homepage.”
• the domain of a property indicates the classes of resources that might have one of these properties. For example, the foaf:mbox property has the domain foaf:Agent, because it is Agent resources that have this property. Another way to say this is that “foaf:Agent is the domain of foaf:mbox.”

I’ve been doing a lot of reading over the last few weeks to try to get a better handle on where things stand with the Semantic Web, especially in terms of the enabling technologies (like RDF and OWL) and existing applications. The RDF Primer provides a thorough (a very, very thorough) introduction to RDF which I probably need to re-read soon. And from my limited reading it looks like OWL just builds on top of the RDF foundation by providing an even more precise way to specify the relationships between classes, constraints on properties, and so on. A majority of the software is written in Java, which is no surprise, but it looks as though there are at least a few RDF libraries for Ruby, such as Dan Brickley’s RubyRDF and Dominic Sisneros’s rdf-redland.

In terms of applications, and especially those that are easily accessible to someone like me, I’ve only just started looking around. I spent a lot of time yesterday reading about the Friend of a Friend (FOAF) project, which has the goal of “… creating a Web of machine-readable homepages describing people, the links between them and the things they create and do.” The idea is that you create a special RDF file (typically named foaf.rdf) and place it in some publically accessible place on the web. For example, I’ve now added a button to this blog which links to my FOAF file. By placing a special tag in the metadata of your web page(s) to “advertise” this file, special web crawlers can collect FOAF information about anyone on the web who cares to publish a FOAF file in this fashion. Now I just need to find out how having done that is going to make my life better.

“As our boat touched the sand and the ramp went down, I became a visitor to hell.” – Private Harry Parley, on landing at Omaha Beach with the 116th infantry on D-Day.

That pretty much sums up my two trips to France as well.

The next Java profiling tool I looked at, and which I think I’ve settled on, is aptly-named Eclipse Profiler Plugin (EPP). Unlike the Extensive Java Profiler (EJP), this one’s truly an Eclipse plugin. Like EJP, the EPP lets you view the per-method CPU time (and other measurements). The difference is that it’s done dynamically; no more waiting for the job to finish, dumping a huge log file, and then using a separate postprocessing tool to analyze the results.

Something that both of these tools seem to be missing, and which I would like to see, is an API that gives me a lot tighter control over when profiling is turned on or off. The EPP does give some control over filtering out classes from certain packages, and turning profiling on and off when you enter or exit one specific method, but I’d like to see more done in this area. Another thing I’m looking for is better tutorial documentation about how best to use such a profiling tool. It’s imperative that the documentation tell you which button to press to trigger a certain action, but it’s more important in my mind to give guidelines about when certain profiling tools are useful and how to get the most benefit from them. A lot of times I find that I’ve run the test, am looking at the profiling results, and still am no closer to understanding where all the time’s going.

The last tool I looked at, and one which I’m still interested in, is JFluid from the Sun Research Labs. This one’s a little more invasive in the sense that you’re actually replacing the stock Java 1.4.2 Hotspot VM with a modified version from the JFluid project. This modified JVM supports dynamic bytecode instrumentation, which means that you can actually change the parts of the program that are being profiled while the program’s still running. Furthermore, by selectively instrumenting certain parts of the code (while leaving others alone) you don’t suffer the performance hit that many other profiling tools impose when they effectively instrument every method call.

JFluid also has some nice tools built in to its GUI for visualizing the heap usage and “object liveness”, i.e. the numbers of objects which survive over successive generations of garbage collection. This is something I didn’t see in the other profiling tools, and it provides an especially useful way to detect memory leaks. If some object(s) survive for a large number of generations, it is quite possible that you’ve got a memory leak. JFluid can tell you where those objects were allocated to give you a head start on finding those potential leaks.