Related link: http://www.opera.com/pressreleases/en/2004/08/31/

The one thing I love most about my P800 is Opera. Now Opera’s web browser is available on Windows Mobile devices too.

Opera manages to fit a staggering amount of polish and functionality into handheld devices. Something I appreciate
in particular are the easy-to-read and good-looking antialiased fonts.

The small screen rendering mode is especially handy in making sense of web pages designed for bigger screens. Here are two screenshots from my P800. The first is in normal mode, and the second with “fit to screen” selected.

title="Normal rendering mode" />
title="Small screen rendering mode" />

The small screen mode may not preserve the beauty of the design, but it certainly makes a site a lot more usable.

Are you a Windows Mobile user? Will having Opera make any difference to you?

Related link: http://www.onjava.com/pub/a/onjava/excerpt/esb_ch6/index.html

An excerpt from chapter 6 of my ESB book, which talks about some of the machinery of the ESB service container has been posted as an article.

Using the ESB service container

Dave

Related link: http://www.sys-con.com/story/?storyid=45908&DE=1

There’s an interview with Don Box that has been published in this month’s .NET Developer’s Journal. I find it interesting because its a very good blend of some technology stuff and some about him.

It covers a broad range of topics, including his getting into the technology education business, his participation in the development of the first SOAP spec, and WSE toolkit, “COM underwear”, and his thoughts on the Indigo project.

One of the reasons I always make it a point to attend his presentations whenever I can is his knack of blending in his personality and sense of humor into everything he does. It definitely shines through in this one- click here to see the full interview.

Dave

Related link: http://chappell.sonicsw.com/JavaOne_ESB_JBI_TS-2664_Chappell.pdf

A number of people have been asking me for my JavaOne presentation on JBI and ESB, so here it is. The presentation is entitled “Integration in the Real World - Java Business Integration and Enterprise Service Bus”.

The presentation focuses on JSR-208, which is an effort within the JCP to standardize a container model and interfaces for hosting integration components as event-driven services in a protocol-independent fashion. The presentation also talks about what an ESB is, and how the JBI and ESB are intended to work together.

Let me know if you have any questions on it.

Dave

The moral first: Knuth Knows All.

It’s fun to see how we move on. I’m writing two books at the moment and preparing two more. One of these is the sequel to my Content Syndication with RSS, that I wrote two years ago. During that time, I was in London, and for most of book - until a total hard drive failure pushed me over the edge to Apple righteousness - working on PC. An enormous tower with about six fans: it was like writing inside a busy hairdressers.

Anyway, I’m now in Italy, on a Mac, and infinitely more organised, more prepared, better than I was then. And more aware of the process of writing one of these sorts of books. For me, at least, the average syndication specification document is not interesting enough to dedicate a few months of my life to rewriting in O’Reilly style. But using that chapter as an excuse to hack on a load of problems and serve them up as examples most certainly is. Anyone who starts writing one of these books understanding everything about the subject, and knowing exactly how to code the examples, is a fool. And, frankly, nowhere near ambitious enough. As Disraeli said:

The best way to become acquainted with a subject is to write a book about it.

But, with so much work to be done, I’ve been drawn to thinking about the process of writing. What is it that I like to do and what things are drudgery? Talking this through with some other authors, I find some agreement: you spend so much time working out the solution to a problem, that by the time you come to write it up, you’re both bored with it and resentful of the future readers for not knowing the answer themselves. The fun leaves at this point, especially as you then have to wrangle with the obligatory and baroque Word template thrust upon you by the publisher. O’Reilly aren’t the only ones to do this.

The answer, at least it seems for me, lies in Donald Knuth’s concept of Literate Programming

Let us change our traditional attitude to the construction of programs: Instead of imagining that our main task is to instruct a computer what to do, let us concentrate rather on explaining to human beings what we want a computer to do.

The practitioner of literate programming can be regarded as an essayist, whose main concern is with exposition and excellence of style. Such an author, with thesaurus in hand, chooses the names of variables carefully and explains what each variable means. He or she strives for a program that is comprehensible because its concepts have been introduced in an order that is best for human understanding, using a mixture of formal and informal methods that reinforce each other.

Literate Programming isn’t a new idea - Knuth’s paper quoted above is from 1984. But it is a powerful one. And reading through it, I’ve developed my own system of documenting the scripts as I go using POD. (I’m a Perl guy. I know, I know.)

The POD is more than extensive commenting, because you can give it some form of structure, and by using the myriad POD modules on CPAN, can parse it into pretty much anything. This means that I now have a suite of scripts that check my code, check the POD to see that everything in the code is written up, tidy the code, format the whole thing nicely and then dump it into an OpenOffice document, with the correct O’Reilly template already embedded. This is heaven.

For sure, POD is Not Literate Programming, but it’s close enough, and when jiggled around with, is exactly what I need to go from concept to manuscript with as little fuss as possible. The ease in workflow alone probably saves me half an hour a day - but more to the point, the enforcement of a certain thinking pattern makes writing scripts for books (a different thing, I would argue, than scripts for real world use) all the easier.

I’m rather excited about the way this is working out, and the increase in productivity it’s giving me. I’ll let you know how it evolves, but in the meantime, is there anything else I could be doing to ease the way from brain to paper? Use the Talk Back below and share your ideas…

Do you automate your writing in any way? Is there anything else I can do to ease my efforts?

A week ago, C. Michael Sperberg-McQueen closed the Extreme Markup Languages conference by questioning models. I wasn’t sure what I thought about it at the time, but this time, his closing sermon is reverberating.

Sperberg-McQueen’s question was:

Does XML have a model? A supermodel? Does it matter?

After talking about several senses of “model”, including model trains, which I especially appreciated, Sperberg-McQueen talked about people who ask for “the model” for XML, or charge that the entire project is fatally flawed because it doesn’t have one. While the word “model” is extremely difficult to define and seems to change from situation to situation, it gets used as a bludgeon on a regular basis.

Model questions have caused plenty of grief in the XML world, with the Infoset standing in as a model for some people, the DOM for other people, RDF `for others, and application-specific models for others. There seems to be a deep and conflicted emotional need for models. Even within an application domain, there may be questions about the value of particular models, demonstrated by the continuing battles over various kinds of models for Topic Maps discussed at the conference.

Sperberg-McQueen’s question seemed to fit the overall conference very well. A presentation by the W3C’s Eric Miller (co-authored with Sperberg-McQueen) on integrating RDF with XML through XML Schema had faced some fairly hostile questions from people asking what value the RDF model added to the project. In a series of presentations on overlapping markup, it was clear that there are cases where the same document can and indeed should offer applications the choice of multiple ways to model it.

After years of disagreeing with Sperberg-McQueen about various aspects of the XML universe, I’m happy to say that he’s inspired some new lines of thought for me, and reinforced others. (I doubt he’d agree with all of these, of course!)

I first saw XML as an effort to trade a bit of discipline on the part of markup creators for improved processability, but that’s lurched entirely too far to processing and away from people, driven by an obsession with machine-comprehensible models. By re-examining the question of models and rejecting the notion that there must be one true model (even for a given project), I’m freed to accept the human reality that even simple documents have multiple interpretations.

I can embrace Walter Perry’s long-standing argument that understanding happens in the processing applied to a document, not the external constraints used to describe it.

I can take a fresh look at Layered Markup Annotation Language (LMNL) and enjoy that it provides a syntax for what I want to do without concern for the issues that bedevil the model.

I can’t say that I expect this viewpoint to catch fire too rapidly, as it goes severely against the grain of so much of computing culture, but it does a nice job of explaining how XML syntax caught on so wildly even if the model wasn’t clear. Letting go of ambitions for complete communication or universal exchange makes it much easier to focus on particular projects that solve immediate problems, using only as much standardization as a particular problem needs.

After all, we’re just exchanging data, right?

Do models get in your way sometimes?

Related link: http://www.w3.org/Submission/2004/SUBM-ws-messagedelivery-20040426/

In my recent posting which referenced the announcement of the W3C “Member Submission” of WS-Addressing, I forgot to mention that this is the 2nd of such submissions that have recently occurred. On April 26, 2004, another addressing specification, WS-MessageDelivery, was submitted to the W3C as a “Member Submission”. Both WS-MessageDelivery and WS-Addressing “address” the same issues, which is how to specify metadata in an XML message that describes endpoints or destinations. Information such as From, To, ReplyTo, and FaultTo are specified.

Now that both specifications are submitted to the W3C, one can only hope that the submitting companies will work together through the W3C Working Group process and come to some convergence. I hear rumors (or perhaps I’m starting one) that the recent submitters wish to fast-track the current spec through the process, yet also plan to use the previous WS-MD spec as input. That’s all good news if you ask me.

Dave

Related link: http://www.w3.org/Submission/2004/SUBM-ws-addressing-20040810/

The WS-Addressing specification has been submitted to the W3C by the joint authors. While this marks a significant step forward in the “standardization” of the WS-* stack of specs, this is only the first step in the development/ratification of the spec within the W3C process.

The submission in its current state is referred to as a “member submission”. This means that WS-Addressing has now become more “standard-y” than it was before, but not much more. Nevertheless I am feeling positively optimistic about this.

One of the next steps that would logically follow is the formation of a Working Group. Sometime after that it eventually comes out the other side as a W3C “Recommendation (with many steps in between).

The concept of addressing is something that most of the other Web services specs rely on. WS-Addressing specifies an interoperable EndPoint Reference (EPR) in the form of SOAP header information. The EPR contains information about where messages come from, where they should go, and where to send them when they are bad :) More specifically, the spec defines headers such as MessageID, From, To, ReplyTo, and FaultTo.

I’m feeling very positive about this. Because WS-Addressing has been considered proprietary, it has been a bone of contention within other standards efforts such as WS-BPEL and WS-Notification within OASIS. WS-BPEL decided to abstract the concept so they didn’t have the direct dependency. In the WS-Notification Technical Committee (TC), we have been faced with possibly making the same decision.

One of the issues surrounding the use of WS-Addressing in other standards efforts has been the Intellectual Property Rights (IPR) of the spec authors. Making this submission may makes that less of an issue, although I’m not completely clear on how much less. Perhaps someone else can comment on the IPR issue.

Interestingly enough, this specification is now at the same status and IPR policies as WSDL 1.1. Most people don’t realize this, but WSDL 1.1, which is in widespread use, only ever got as far as a “member submission” (formerly known as a “W3C Note”), and is encumbered with the IPR as defined in the spec.

Dave

Related link: http://www.w3.org/TR/2004/WD-rdf-dawg-uc-20040802/

Among the several hats I wear these days — including Managing Editor of O’Reilly’s XML.com — I’m also a member of the Data Access Working Group (DAWG), which is working on standardizing a query language and access protocol for RDF, the lingua franca of the Semantic Web.

The DAWG has recently released the 2nd draft of its Use Cases and Requirements doc, which we’re encouraging people to read and comment on. This document contains an odd baker’s dozen of use cases — little stories where we think a standard RDF query language would help you get the job done. It also includes some requirements and some design objectives. The former are things that we’ve put into the critical path: we won’t be done till they are. The latter are things which we think would be good to do, but which we aren’t (yet) willing to put into the critical path.

Where do things stand now? The WG is trying to figure out what kind of interest there is from Semantic Web, RDF, XML, and web service developers in a few of its proposed design objectives, including:

1. 4.2 Aggregation Graphs
   

   RDF can be used for data integration and aggregation. RDF repositories are built by merging RDF triples from several other RDF repositories or from non-RDF sources converted to RDF. Such an aggregations can be real or virtual.

   It must be possible for the query language and protocol to allow an RDF repository to expose the source from which a query server collected a triple or subgraph.

   This objective is related to the provenance issue — consider an assertion A. It’s often very useful to know which RDF graph A came from, even after you’ve aggregated A with lots of other assertions.

2. 4.5 Aggregate Query
   

   It should be possible to specify two or more RDF graphs against which a query shall be executed; that is, the result of an aggregate query is the merge of the results of executing the query on each of two or more graphs.

3. 4.5.1 Querying Multiple Sources
   

   It should be possible for a query to specify which of the available RDF graphs it is to be executed against. If more than one RDF graph is specified, the result is as if the query had been executed against the merge of the specified RDF graphs. Query processors with a single available RDF graph trivially satisfy this objective.

   How feature rich should the DAWG protocol and query language be? One of the promises of the Semantic Web is the ability for Bob to aggregate data that Carol, Alice, and Ted have published on the Web — without any more explicit coordination between them.

   Objectives 4.5 and 4.5.1 are two variants of RDF aggregation built into the query language and data access protocol. If this is the sort of thing you want to be able to do, let us know!

4. 4.6 Additional Semantic Information
   

   It should be possible for knowledge encoded in other semantic languages—for example: RDFS, OWL, and SWRL—to affect the results of queries executed against RDF graphs.

   There are two standardized ways to structure RDF data: RDFS and OWL. Should we build syntactic sugar into the RDF query language for asking queries about RDFS and OWL constructs? For example, inverse functional properties are an important OWL concept used in FOAF data. It might be a good thing to be able to ask about IFPs in an RDF query over a set of FOAF instances.

In other words, the Working Group is asking for community feedback. That’s part of our job. You can help us do it!

I’ll make sure comments left here on this weblog entry come to the attention of the DAWG. Thanks!

Let the DAWG folks know what you think

Related link: http://www.ondotnet.com/pub/a/dotnet/2004/08/09/gtk_mono.htm

Quietly, something wonderful has happened. Windows .NET developers can now target Linux and OS X without ever changing their OS.

As my friend and co-author
Niel Bornstein describes in his article for ONDotnet, Using the Gtk Toolkit with Mono, Windows .NET developers can
use Gtk# to create user interfaces that will function on Windows, Linux and Mac OS X.

The Mono world moves so fast that since Niel wrote that article, Paco Martinez announced a
Gtk# Windows Installer that allows Visual Studio .NET based
developers to develop against Gtk# too, completing the toolset.

height="371" width="531" alt="Glade# project from Visual Studio" />

Visual Studio in action creating a Glade# project

Gtk# is a bit of a different layout model than experienced
Windows.Forms developers will be expecting, but once you’ve gotten used to it, you appreciate its flexibility. And for newcomers to Gtk#, you should start by reading chapters 4 and 5 of Mono: A Developer’s Notebook!

Comments or questions?

Related link: http://www.theregister.co.uk/2004/08/03/wi-fi_aerial_gun/

Someone at DefCon showed off their Wi-Fi antenna which is made from a modified M16 rifle and scope. Supposedly has a ten-mile range. If you made it look less gunlike, it might be a nice project to have in Make.

Related link: http://www.svgopen.org/2004/scheduleDetail.do

The program for SVG Open 2004 is finally available. Its sheer diversity and the innovative nature of a good number of the talks is a tribute to SVG’s flexibility and power.

You will of course find the traditional domains in which SVG was adopted immediately such as mapping applications, and mobile content and services. But furthermore, you will find talks on how SVG integrates into the surrounding technologies — the forte of XML technologies — such as XForms, XSLT 2.0, XHTML, sXBL, or Web Services. There are also sessions on how to use it in conjunction with Perl or PHP, and how the new JSR-226 allows one to write SVG applications on mobile devices with Java.

Moving away from the simply technological to the applicative areas, there are talks that are quite alluring relating to location-based services, inter-human relationship visualisation, Kanji graphetic dictionaries, aeronautical charts, train traffic monitoring systems, SVG for teachware, “Semantic Webapps”… the list seems to go on and on.

And of course, there are sessions on SVG itself, introductions, a “Wow! Session” for the tricks, and many more.

That’s one conference not to miss!

http://www.google.com/search?q=%s

g site:w3.org emacs
g "bob quine" OR "robert quine"
g "dave thomas" -wendy's

Has anyone else developed a dependency on this?