I have just arrived in Japan. I’m over here for a week to coincide with the launch of the Japanese translation of the ESB book. I’m looking forward to good week of press interviews and corporate visits.

I’ll also be speaking at a SOA seminar that is hosted by Sonic Japan. The Seminar will be held Wed evening at the Park Hyatt Tokyo, which is where the movie “Lost in Translation” was filmed. Its going to be an interesting week, learning the Japanese culture and interacting with the Japanese in the SOA architect forum environment.
Dave

Related link: https://www.pontomidia.com.br/ricardo/colinks/english.html

If you credit >Jef Raskin with nothing else, I think you can at least credit him for coming up with what must be the best quote ever about Steve Jobs:

He would have made an excellent King of France.

Though Raskin himself seems to have been known within the Mac team for being a little overzealous in laying claim to ideas (see the I Invented Burrell anecdote over at folklore.org), it seems like everybody agrees that it was his “computers should make tasks easy for people, not the other way around” vision, and his enthusiasm about the whole “information appliance” concept, that got everything started.

>Andy Hertzfeld has pointed out why it’s not really accurate to call Raskin “The Father of the Macintosh”. But Hertzfeld did also have this to say:

One of the biggest things I give Jef credit for was putting together the very beginnings of the Mac team with some extraordinary people who didn’t necessarily have the credentials, but had everything else to do something great.

Anyway, I wonder if what Raskin left behind at Apple was a lot more important than some people might give him credit for. I think probably the most telling quote from any of the people from the Mac team who were quoted in the press reports about his death was the following one from >Bill Atkinson:

One of the things that Raskin taught me early was that the person was important and the computer wasn’t.

Today, that just seems like common sense. But it wasn’t at that time. At least you definitely couldn’t tell it from the other computers that were available then — including the Apple II.

If you read about Raskin’s personal history, you’ll realize that he was obsessed from very early on with the “computers should make tasks easy for people, not the other way around” idea, back when most others didn’t think it was too important. In his Master’s thesis, published in 1967 (titled, by the way, “The Quick-Draw Graphics System”), he wrote that his work was driven by a philosophy “which demanded generality and human usability over execution speed and efficiency”.

I reckon that if you were to have rounded up all the other computer scientists who, in 1967, were writing or even thinking seriously about “human usability” as a primary design goal for computer applications, you could have fit them all in a Volkswagon microbus.

About four months ago I was commissioned by a small company to research the Web Services space and define a set of best practices for developing web service components and writing composite applications. This is quite an open ended assignment but the aim is basically to come up with an architect and developer play book. There are many introductory articles on developing service-based applications but this company wanted the specific details of taking a service specification through the software development lifecycle, from inception right through to deployment. They want to take this applications through several iterations and understand how to propagate changes.

They want to be able to gather information and understand the scalability, maintainability, performance, evolution aspects of this product and how it applies to architectural and design decisions. It is a journey that will primarily cover the technical aspects of web services, but will occasionally look at the business side of the ledger.

The web services market covers quite a bit of territory and overlaps other market segments. Some of the technologies, standards or ideas we have already encountered include

WSDL - Web Services Description Language
SOAP - Simple Object Access Protocol
REST - REpresentational State Transfer
BPML - Business Process Modeling Language
BPEL - Business Process Execution Language
BPMN - Business Process Modeling Notation
UDDI - Universal Discovery Directory Interface
SOA - Service Oriented Architecture
POA - Process Oriented Architecture
WSCL - Web Services Choreography Language
WS-* - A whole lot of specifications that relate to the web services stack

Fortunately, we have been playing in this space for sometime and have experience with most of these technologies. The difference with this project is that we need to a deeper understanding of these technologies, which entails reading the specifications or the concepts or looking at the API again and again.

During my 20 years in the software space I have come up with some important observations, which I call What I Now Know (WINK) :-).

WINK-1
======
Read a specifications multiple times (i.e. 3-4) before developing or using it. The later reading will provide stronger foundations for any work ahead and will minimize rework.

Companies like Amazon, eBay and Google have already released Web Services, which support both WSDL/SOAP and REST style interfaces. These web services are used extensively, so we know they work. Are they designed using best practices? Are the abstractions adequate? What are the architectural constraints? What are the scalability characteristics? At the moment we do not have adequate front line experience to make a value judgment on the architecture or the design of these web services.

During the initial period we have already made some false starts and incorrect assumptions but have managed to overcome them and move forward. These stories will be the subject of other blog entries.

I will close with a classic quote from Lao Tzu (Chinese Philosopher) because these few words convey both simplicity and conciseness of what we are trying to achieve

To know that you do not know is best
To pretend to know when you do not know is a disease.

Drop us a line if you have been down this road.

Related link: https://sagehill.net/book-description.html

Bob “the DocBook Answer Man” Stayton has released the third edition of his guide to publishing DocBook documents.

A PDF version is available for purchase; an HTML version is also available online. Bob’s site says a paperback version will be available from Amazon some time in Marh.

This book is pretty much essential if you do any work at all with DocBook. It covers just about every possible aspect of DocBook publishing (that is, generating HTML, PDF, HTML Help, man pages, etc., from DocBook XML source) — everything from general tool setup down to the level of stuff like fine-tuning content of headers and footers, title pages, cross-references, indexes, etc.

The previous edition was already extremely thorough, but this edition adds a significant amount of content — about 150 pages worth. It has now grown to 560 pages. Take a look at the list of changes.

Some of the stuff added includes brand-new sections on generating side floats and marginal notes (in PDF output) for DocBook sidebar elements. There is also a new section on generating Eclipse help, and new chapters specifically devoted to working with lists and footnotes.

Bob is one of the developers in the project that maintains the DocBook stylesheets (I am too, by the way), so I guess part of the reason the book is now in its third edition is that Bob keeps adding new features to the stylesheets — and he tends to follow the “he who adds its also gets to document it” philosophy. :) He’s the one who added the side-float/marginal-note support, for example. Another thing he’s responsible for contributing is the implementation of XSLT support for the DocBook Olink element — a pretty sophisticated system that enables relative links to be maintained among rendered DocBook documents (all covered in detail in his book).

Anyway, I highly recommend the book. Buy the PDF and/or paperback version (when it becomes available).

Related link: https://www.artima.com/weblogs/viewpost.jsp?thread=95113

A new piece by Carlos Perez suggests that SOAP is comatose, and REST (HTTP GET/POST/PUT/DELETE + XML) is waking up. Reading it left me a bit nostalgic, and wondering what might have happened if SOAP had never appeared.

Yes, I know counterfactuals are ridiculous, and that the computing culture of the time definitely drove a lot of the decisions that went into making SOAP the [triumphant success | utter debacle] that it is today. Perez suggests that REST may be emerging from the train wreck as a success, but I wonder if it’s at least possible to think of a world where SOAP never happened and technologies like REST and BEEP had greater opportunity to flower.

From my (admittedly jaundiced, biased, etc.) perspective, SOAP and its ever-growing family of specifications emerged because vendors needed something more concrete than design services to sell their customers, and because the hype wave around XML had promised too much that couldn’t be delivered immediately. XML provided one layer of data structure, and the rest was left to users. While XML was very capable, its tremendous openness troubled people used to much more constrained environments. SOAP felt like a way to provide those constraints while still offering much of the openness.

SOAP has never been and still isn’t necessary as a means of getting XML from one place to another. HTTP exchanges of XML were and are common and growing (even when they don’t precisely follow the REST model), and you can even send XML over a socket without further fanfare if the sender and recipient share expectations. For cases where that wasn’t sophisticated enough of an approach, BEEP promised an extensible protocol system to match the extensibility of XML. XML-RPC offered much less extensibility, but was perfectly adequate for a lot of simple and even many complex applications.

Neither REST, BEEP, nor XML-RPC, of course, came with the corporate imprimatur of Microsoft, IBM, BEA, and more. When the time came for the W3C to address the question, it pursued the familiar tracks pushed by its largest members and many of its newest members, who’d apparently seem the lovely diagrams of magic clouds at XML conferences and decided Web Services would solve their problems.

Without SOAP - say, if XML hadn’t registered so high on the hype meter, and had a quieter few years to develop best practices - we might have had REST emerge four or five years ago. The parts have been around a long time, and their use isn’t that difficult. BEEP might have led developers down different paths, capable of handling the multi-level processing demands of the WS-* family, but doing so in more elegant and perhaps with fewer press releases announcing new competing semi-standards.

I know, I know. It’s too late for all of this now. REST still has a chance, but BEEP has largely vanished to history. Customers and vendors alike spend time wondering what’s going to happen in the WS-* cloud, and that disaster has happened slowly enough that people still seem to stay along for the ride, always hoping that it will finally get better. We might be in a different mire now if things had gone differently, but I can’t help thinking the industry would have done better to avoid the SOAP dead end.

Could we be further along than we are today?

Related link: https://ws.apache.org/axis2

The Apache Axis team has been working hard on a redesign of the runtime engine in order to support a more flexible SOAP processing model, in anticipation of other related Apache WS-* projects. The Axis2 project is centered on a new representation for SOAP messages called AXIOM (AXIs Object Model). According to Glen Daniels, this is definitely a rough cut, but nonetheless a significant milestone in working towards a new architecture. The announcement text, which came from the Apache Axis 2 team, is included here for more details….
Dave

The Apache Axis2 Team is pleased to announce the first milestone release of Apache Axis2 and the release is available at
https://ws.apache.org/axis2

Downloads:
https://cvs.apache.org/dist/axis/v2.0-M1/axis2-M1-src.zip
https://cvs.apache.org/dist/axis/v2.0-M1/axis2-M1-bin.zip>https://cvs.apache.org/dist/axis/v2.0-M1/axis2-M1-bin.zip

Release Notes:
https://cvs.apache.org/dist/axis/v2.0-M1/release-notes.html

Overview of Apache Axis2
===========================
Axis2 is an effort to re-design and totally re-implement both Axis/Java and
(eventually) Axis/C++ on a new architecture. Evolving from the now standard “handler chain” model which Axis1 pioneered, Axis2 is developing a more flexible pipeline architecture which can yet be managed and packaged in a more organized manner. This new design acknowledges the maturing of the Web services space in terms of new protocols such as WS-ReliableMessaging, WS-Security and WS-Addressing that are built on top of the base SOAP system.

At the time Axis1 was designed, while it was fully expected that other protocols such as WS-ReliableMessaging would be built on top of it, there was no proper extension architecture defined to enable clean composition of such layers. Thus, one of the key motivations for Axis2 is to provide a clean and simple environment for extensions like Apache Sandesha and Apache WSS4J to layer on top of the base SOAP system.

Another driving force for Axis2 is to move away from RPC oriented Web services towards more document-oriented, message style asynchronous service interactions. The Axis2 project is centered on a new representation for SOAP messages called AXIOM (AXIs Object Model). AXIOM consists of two
parts: a complete XML Infoset representation and a SOAP Infoset representation on top of that. The XML Infoset representation provides a JDOM-like simple API but is built on a deferred model via a StAX-based (Streaming API for

XML)
pull parsing API. A key feature of AXIOM is that it allows one to stop building the XML tree and just access the pull stream directly; thus enabling both maximum flexibility and maximum performance. This approach allows us to support multiple levels of abstraction for consuming and offering Web
services: using plain AXIOM, using generated code and statically data-bound data types and so on.

At the time of Axis1’s design, RPC-style, synchronous, request-response interactions were the order of the day for Web services. Today service interactions are much more message-oriented and exploit many different message exchange patterns. The Axis2 engine architecture is careful to not build in any assumptions of request-response patterns to ensure that it can be used easily to support arbitrary message exchange patterns.

–The Apache Axis2 Team

I’ve had a small flurry of odd questions about how to do a good job of creating XML vocabularies. The answers are different for every vocabulary, but here’s what I’ve learned in the past few years.

Documentation, documentation, documentation!

Whatever you do, make it easy for users to figure out how they’re supposed to use your vocabulary. Start writing documentation when you start developing, and use the documentation to keep yourself clear about what you’re doing. Prose descriptions accompanied by a rich set of examples provide users with far more help than a bare schema. “Tag abuse” and the many weird application issues it creates can be greatly reduced with good documentation. Make your documentation easy to find - RDDL’s approach of putting both human and machine-readable documentation at the namespace URI is a good one.

Listen to the problem you’re trying to solve.

This one comes in a lot of forms. Sometimes it’s requirements gathering, other times it’s notes on a napkin about what a process needs to operate. However you do it, make sure you keep thinking about the problem throughout your development process and afterward. Be sure to document what the problem is and how you think you’ve addressed it. Contemplate the possibility that your solution might create worse problems.

Step away from the program.

It’s tempting to write XML vocabularies that directly reflect the data structures you’ve written into a program. There are several large problems with this. First, binding data to program structures that tightly often makes it more difficult to make things work when either the data format or the program structure change. Second, you may well find you’ve limited how well your vocabulary plays with programs that run in different environments or with different assumptions. Perhaps worst of all, however, the structures you’ve used in your program may be far from the ideal way to present the same data in XML. (Take a look at WordprocessingML or Apple’s plists if you don’t believe that object serialization can produce excessively complicated markup.)

Plan for change.

Versioning is tough everywhere, but XML offers some opportunities to make things easier on yourself. You can leave spaces for further expansion, creating vocabularies whose processors can tolerate the possibility that they don’t understand every single part of a document and work with what they do know. You can use schema languages like RELAX NG and Schematron, which are more tolerant of changing, modularized, and interlinked structures than DTDs or W3C XML Schema. And make sure that places where change is foreseen are well-marked in the excellent documentation you produce.

Remember that you’re creating documents, not just schemas.

It’s tempting to look at XML vocabularies as things like C structs, where you define the structure and then a program comes along and fills them. Unlike structs, however, XML documents are open to anyone who happens to encounter them, not just your programs. People and programs write XML in all kinds of ways, many of them chaotic. Make sure you’ve considered what the document structures look like, not just what the schema structures look like.

Take advantage of hierarchy, except when you can’t.

XML is all about trees. Elements contain attributes, other elements, and text. Containment is everywhere in XML. If two or more things go together, put them in a common parent element. While it’s certainly possible to go crazy and add too many levels to an XML document, there’s a balance between possible and necessary that isn’t too hard to achieve in practice. There are also times you need to cut across hierarchies - cross-references and keys are historic examples - and you should take advantage of XML’s facilities for doing that. If you don’t find hierarchy a good fit overall for your document structure, however, you should probably contemplate leaving XML behind and using a different approach entirely.

Learn XPath.

If it’s easy to get to your information using XPath 1.0, you’ve probably created an XML document structure that other people can process easily. If you find yourself needing to use a lot of named axes to get around, seeking an element’s parent’s sibling’s parent to interpret that element’s meaning, you probably need to take a close look at your vocabulary and contemplate restructuring.

That’ll do for the basics. There’s lots more, of course, but given that foundation, there’s hope of people getting it right.

Any more best practices?

Related link: https://www.pvrblog.com/pvr/2005/02/rumors_apple_ac.html

PVRBlog notes the rumor on the street is that Apple is looking at acquiring Tivo. What a wonderful reality that would be if true! The mind runs wild with the possibilities.

Related link: https://norman.walsh.name/2005/02/16/witw-part-1

As part of his ongoing technical explorations on his norman.walsh.name site, Norm Walsh has put together a web service that he has christened Where in the World (WITW, for short) (tagged nwn-whereintheworld for Technorati tracking). I guess it is still somewhat in the experimental stages, and I’m sure he’ll be doing more refining. But the Web-based form interfaces for getting data in and out of it are all in place. Took me a little while to figure out how to get to them, but once I did, I managed to set up a WITW is Michael Smith? page for myself, and even added data about a few of my neighborhood landmarks.

So from taking a look at my WITW page, you can get the basic idea: given a username, the service returns information about where (in the world) that user is located. Meaning latitude and longitude. With links to maps generated at third-party sites (multimap and MapQuest). And the but-wait-there’s-more parts are that it gives you a list of landmarks (if any) that are relatively close to the location of that user. And a list of other users that are within some proximity.

Let other people know where you are

So far, Norm has made the service available to anybody who takes the time to register and add some data about themselves. A few people other than me have already. You can find their info in the also-very-cool WITW Are They? Atom feed that Norm has also conveniently provided.

And it’s probably not too late for you to be the first kid on your block to set you a WITW feed. All you need to do is:

1. Go through the short registration process
2. Once you are registered and authenticated, go to the WITW Am I Now? page to add or update your location information
3. (Optionally) Go to the Update Landmark page to add or update information about landmarks. Which can be wherever — not necessarily only your own local ones (though of course I guess the main point is to add ones that are local to your area, especially if there aren’t any in there already)

Anyway, I feel a bit lonely right now being the only WITW user anywhere near Yoyogi Park. So please especially take some time to get a page set up for yourself if you are living in Tokyo. Or even in Honshu…

One thing I can tell from looking at Norm’s own WITW page is that he really is way the hell out in the middle of nowhere. Though it seems like a nice nowhere. Especially compared to where I live, which is often a little too “somewhere” for me. Maybe that’s why most of the landmarks I added are parks…

Can you recommend a good hosting service? is a question I
sometimes get asked, and one that comes up pretty frequently on
some of the mailing lists I subscribe to. Along with the cost and
how much RAM/diskspace/bandwidth the hosting service provides, the
main criteria seems to be what PHP/MySQL/etc. versions they run,
and what maximum number of e-mail addresses/domains/databases/etc.
they limit you to.

When asked for my opinion (and sometimes even when not asked for
it), I’ve started suggesting to people that if they really want
complete control over their sites and domains, they should host them themselves.

Perhaps it’s because I am myself sort of a recent convert[ id="convertref" href="#convert">note1] to the do-it-yourself Way. It was only
relatively recently that I finally moved my own Internet presence
completely over to self-hosting. The main thing that had prevented
me from doing it before was that I don’t have, need, or want any
wireline or broadband access at home[ href="#myhome">note2]. So I couldn’t run a machine from home.
And I can’t afford to pay a provider the cost of remote hosting of
a physical machine.

Houston, we’ve got root

Anyway, these days there is another alternative: some hosting
services now provide “virtual machines” that run href="https://en.wikipedia.org/wiki/User-mode_Linux" >user-mode
Linux. In a nutshell, user-mode Linux enables an actual
physical machine to sort of be “partitioned” into several virtual
machines. That’s what I have my site set up on. I have root access
to the machine and can install or remove anything at any time,
create as many domains and e-mail addresses and database instances
or whatever on it as I want — can even reboot the machine at any
time, or replace the OS kernel.

There are a href="https://user-mode-linux.sourceforge.net/uses.html" >number of
providers that now offer user-mode Linux virtual machines.
The one I’m using is href="https://www.bytemark.co.uk/index.html" >Bytemark. But
there are others that are bit cheaper than them. One of the
cheapest I’ve heard of is href="https://www.redwoodvirtual.com/" >Redwood Virtual. Their
lowest-cost plan is US$10 per month/$100 per year for a 64MB RAM, 2
GB diskspace, 20 GB bandwith setup. The next level up is $20/$200
for 128MB/4GB/40GB.

All of the providers give you a choice among at least one or two
Linux distros/kernels you can run. And you can change it at
any time. Bytemark offers Debian, Red Hat, Gentoo, and Slackware.
Redwood has Debian and Fedora.

With great power also comes great responsibility

The best thing about it is that you really do have complete
control over the host. I run my own mail server and DNS name
server on mine, along with the web server. You can add new domains
and virtual (web) hosts and new e-mail addresses whenever you
want, without needing to wait for an admin to make the changes.
And you can install the very very latest versions of any software
you want. Easily. Especially if you run Debian.

Of course the big downside is also that you have complete control
over the host. Basically, the only time the provider is obiligated
to give you any support at all is if there’s some hardware
failure on the physical box that your virtual machine runs on.
They know nothing about the software environment on your
individual host (because, little missy, you are the one who set it all
up). So if you muff something up, you’re basically on your own –
you are your own tech support.

Time for the altar call

Anyway, of course it’s not the right solution for everybody. But
if you have experience with Linux, it might be worth trying — you
could register a new domain (or move over some extra or unused
domain you already have now), then sign up for a month or two and
see how it goes.

That’s what I did. And you can see where I am now. A true-blue
thank-you-Jesus convert. And brethren, though I’ve backslid in so
many other areas of life, I reckon (praise God) that I won’t be
backsliding on this particular choice. I was a software sinner
once, but now (hallelujah) I have found the light. Call this my
Testimonial…

Note1 [back] If you’ve
ever had any experience with with fundamentalist religion, you
know that recent converts tend to be the ones that are the most
enthusiastic about spreading the Word. Until they get bored with
it and go back to being really enthusiastic about the stuff they
loved to spend their time doing previously — drinking and
macking, for example. I think that’s mostly the stage where I’m at
now.

Note2 [back] I live in a
tiny one-room apartment in the middle of Tokyo. To me, it is
basically just the place where I shower and sleep. And,
occasionally, eat. I live just a few blocks from my office, where
I have fat LAN access. And there are now more and more WiFi
freespots around. And even when I’m not at one of those places,
I have a wireless (PHS) modem that works pretty much anywhere.
Including on moving buses and trains. Or bars.

Can somebody say Amen?

Related link: https://web-graphics.com/mtarchive/001504.php

My friend Andreas is looking for feedback on what flavor of XHTML to serve up to mobile devices.

Andreas writes:

Support for XHTML Basic is here and that’s probably how it will stay—there is no move to fully support XHTML 1.0 on mobile devices.

So what should we do? Offer two versions of a webpage and serve the appropriate version via CC/PP based content negotiation mechanisms? Or else, just don’t care too much about all this stuff (yet) —it is a bit an esotheric issue as rendering isn’t really affected— and continue offering the same XHTML 1.0 to both desktop and mobile browsers?

If you have comments, please post them over at Andreas’s entry over at the Web-Graphics site.

If you have comments, please post them at https://web-graphics.com/mtarchive/001504.php

Related link: https://simonstl.com/compact/

I didn’t plan to write a book on the .NET Compact Framework when I started programming with it, but I suppose that’s an occupational hazard given that I write and edit books. There are some good books on the .NET Compact Framework (none of which are at my local Borders, another issue), but they all are written for an audience that isn’t me.

I’m not an experienced .NET programmer who’s already familiar with Visual Studio .NET, the regular .NET Framework, or even necessarily C# and VB.NET. Not only that, I don’t think I should have to be any of those things to write applications for a handheld device. The actual application I’m trying to create would be a week’s work maximum in Microsoft Access, but of course the forms and reports that are available in Access don’t run on a Pocket PC. I don’t think anything I’m doing here is that complicated, and I’m surprised by how many cost and skill barriers are in the way.

I also have to say that I really can’t stand Visual Studio .NET, but since it’s the only way to program .NET Compact Framework programs for Pocket PC, I’m pretty much stuck. Dealing with Visual Studio .NET was itself a large barrier for me at the outset of this project, and some explanation of how it works specifically in a .NET Compact Framework situation feels crucial to me.

The books also assume a fondness for Microsoft-blessed solutions, particularly SQL Server and SOAP-based Web Services, that I just plain lack. I’m hoping to collect data on a Pocket PC and transfer it to PostGIS, so SQLite and REST-based service interfaces make a lot more sense to me. They’re not covered in the existing books, of course.

So, much to my surprise, I’ve wound up writing a book along the way of the project I’m working on. I don’t think it will actually add that much time to the work, except insofar as I wander into discussions of technology I don’t need to use in my project. Writing is forcing me to think about what I’m doing more carefully, and to do testing at every step. That should reduce my overall debugging time. (Explaining forces me to think a lot harder about what I’m doing in any case.)

There’s a lot more information at the book site, as I think the Preface gives a better picture of what I’m doing than I can write here, and the first chapter shows what I’m aiming for. I’m about halfway through Chapter 2 (on debugging in VS.NET), and I’ll post more as I finish them. It probably won’t be a speedy process, as this is in my spare time. A few months won’t surprise me, but neither will a year. I do hope to get it out before the next release of VS.NET and the .NET Compact Framework SDK make it all obsolete. It’s also not a polished O’Reilly production, by any means, but it is freely available under the Creative Commons Attribution-NonCommercial-NoDerivs 2.0 license.

I’m also writing this using VB.NET instead of C#. I’m hoping that it will make it more accessible to readers, but the real reason I’m shifting is that C# is too similar to the Java I’ve written for years, and I keep screwing up syntax. (I’d also like to keep my Java skills intact for future work.)

Comments and suggestions are welcome.

Any other ideas on how to lower the barriers to .NET Compact Framework development?

I never had a chance to meet Joey Ramone. Or Johnny. Or Dee
Dee. They’ll all dead now, so I never will. Unless there is a
dingy little corner of the afterworld set aside for Losers [note]. I
guess I might meet them there. Because I reckon that’s where they
are — along with a lot of my other music heroes, like Johnny
Thunders. And I’m certain that’s where I’ll end up, at least.

Anyway, I was thinking the other day that even if I had met
them, I guess I probably wouldn’t have been able to think of much
more to say than just “thank you”. Not that they hadn’t heard that
from thousands of other people, of course. Still, I would have
liked to have had the chance to say a simple “thank you” to them
myself. Especially to Joey.

That line of thinking led me, in a roundabout way, to put
together the following list:

Top Twenty Computing/Internet Innovators Most Deserving of Personal Thanks

• Donald Davies,
  Paul Baran,
  and Leonard Kleinrock
  (packet switching)
• >Douglas Engelbart (mouse, hypertext/windowing work, influence on PARC team)
• >Alan Kay (DynaBook/GUI legacy, Smalltalk, object-oriented programming)
• Fernando J. Corbató
  (Multics, Project MAC)
• >Ken Thompson (Unix)
• >Dennis Ritchie (Unix, C)
• >Douglas McIlroy (Unix pipe-and-filters architecture)
• >Richard Stallman (GNU Project, GCC, GNU Emacs)
• >Bob Kahn and >Vint Cerf (TCP/IP)
• >Robert Metcalfe (Ethernet)
• >Bill Joy (BSD, Berkeley TCP/IP and sockets, vi, NFS)
• >Jef Raskin (Macintosh)
• >Andy Hertzfeld (Macintosh UI Toolbox, Control Panel, etc.)
• >Bill Atkinson (QuickDraw, HyperCard)
• >Tim Berners-Lee (World Wide Web)
• >Marc Andreessen (Mosaic browser, NCSA httpd)
• >Linus Torvalds (Linux)

How to Get from the Ramones to Dennis Ritchie, in a Few Short Steps

The genesis of the previous list is, after thinking back on the
Ramones, my mind turned to thinking about other people I’d like to
say thanks to, face to face, if I had the chance. So I considered
my main interests in life. First comes drinking and skirt-chasing.
Not too many people to say thanks to there that I haven’t already
said it to. So forget about that. Next comes film. Lots of people
there. Too many. So forget about that too.

So then I thought of… computing. That seemed more manageable.
I thought, I bet I can come up a list of say, ten living people
who have made some really kick-ass technical innovations in
computing to rival what the Ramones did for rock and roll. And
then I can plan to try to meet them sometime, somewhere and tell
them thanks, as I wish I could have with Joey Ramone.

The Criteria

So, where to start? Well, after thinking about it for a while,
I decided the best way it would be to first think I about some
basic categories of relatively recent technical innovations I
reckoned to be the most significant. This is what I came up
with:

• distributed communications (packet switching, TCP/IP,
  Ethernet, the Web)
• server operating systems and applications (Unix and its
  heirs)
• user interfaces (GUI/WIMP/hypertext, but also CLI “pipe and
  filters” approach)

At first I had “database technology” on the list, but ended up
dropping it, mostly because, unlike in the case of the other
categories I came up with, no particular names leapt to mind when
I tried to think of who actually came up with the fundamental
innovations that made our current database applications a reality.
That is probably just because I’m not particularly well informed
about database fundamentals…

Anyway, so far so good. That seemed like a pretty manageable
set. At first. But once I started looking into it more, the
problem I ran into is, I realized that there are innovations that
I saw as fundamental but which can’t really be attributed to just
one person. So the list ended up being about twice as long as I
had originally scoped out — there are twenty people in it,
instead of ten. And it also ended up including one person who I
know I won’t ever have the chance to say thanks to face to face
(Donald Davies, who died four years ago).

For the rest, I sincerely hope I have the chance meet them,
shake hands, and tell them how much I truly appreciate what
they’ve done and how much I’ve personally benefitted from what
they’ve done. But since I’m not sure that I ever will have that
opportunity, if you’re reading this and ever have the occasion to
meet any of them, please go ahead and tell them thanks from me if
you do. I’d appreciate it.

Disagree with the Choices?

If there’s somebody missing from the list that you believe
I should’ve included, please post a comment and let me know. On
the other hand, if there’s somebody included on the list that you
might like to respectfully suggest should not be
included, feel free to post a comment and I’ll explain why I made
that particular choice.

Others

Here’s a bonus Top Ten list. I’m not quite sure how to describe
the criteria for this one except to say that they’re all people I’d
really like to say thanks to but that didn’t necessarily fit into
the basic categories to which I tried to limit the first list.

• >Donald Knuth (The Art of Computer
  Programming)
• >Brian Kernighan (K&R, awk)
• Alfred Aho
  (string-matching routines, egrep, the “Dragon Book”, awk)
• Henry Spencer
  (regex C library)
• >Jon Postel (many RFCs, Postel’s Law)
• >Larry Wall (Perl)
• >Steve Wozniak (the Apple II)
• >John Warnock (PostScript)
• >Brian Behlendorf (Apache web server)
• Jon Bosak
  (leadership in the creation of XML)

And yeah, I know that even though he’s on the list, I won’t be
able to tell Jon Postel thanks. Just like Joey Ramone.

Anybody missing from the list(s)? Or someone who you think maybe shouldn’t haven’t have been included? Feel free to post a comment.

Related link: https://weblog.burningbird.net/archives/2005/02/07/introducing-tag-back/

The key ingredient to achieving a flexible SOA is enabling loose coupling between services. Loose coupling between services allows a service, its interfaces, and its data structures to be deployed, modified, or replaced without necessarily affecting all of the other services that communicate or share data with it. Loosely coupled interfaces between services can allow the application logic that resides behind the interface to be changed in accordance with the individual development schedules of the teams that own that business logic.

In SOA that is based on an ESB, this business application logic which is exposed through service interfaces are combined with other intermediary services that help facilitate the communication, data transformation and normalization, intelligent routing between business logic service components. In essence, an ESB provides the mediation logic between business logic assets in a general purpose SOA environment.

A key ingredient of loose-coupling between services is a flexible invocation model. An ESB supports a flexible invocation model which allows the combination of asynchronous event-driven service invocations, and Message Exchange Patterns (MEP) for performing synchronous and asynchronous request-reply service invocations. The communication protocols that transport these invocations are abstractly decoupled from the service definitions themselves. Service invocations in an ESB are built upon MEPs that are configured to use any combination of reliable messaging using point-to-point queuing and publish-and-subscribe delivery modes, Web service invocations via SOAP over HTTP, or other transports such as FTP and email (SMTP).

Another key ingredient of loose coupling is the notion of an abstract process definition that describes the interactions between services in a SOA. When a message arrives “on the bus”, so to speak, it almost never gets assigned directly to a service. Instead, a message which gets placed on the bus gets assigned to an abstract process definition. The process definition, which is orchestrated by the bus fabric, is responsible for dispatching a message to its appropriate service invocations. This allows the degree of flexibility to make changes to the underlying service instances on an individual basis without needing to change all of the associated service endpoints that are involved in the overall process definition. For example, adding stricter validation rules to your services across the board can be done by inserting an intermediary validation service at the beginning of each process definition. This insulates the downstream applications and services from having to retool their own validation logic.

The uniqueness of using an ESB to build such a loosely-coupled SOA is these abstract process definitions, including the MEPs that they control, are configured into the bus, rather than being hardwired into the service endpoints themselves. Furthermore, an integration architect uses a graphical modeling tool to visually describe the orchestration between service invocations. These service orchestrations, which are built upon the configurable message exchange patterns, represent business process definitions that can be readily changed and augmented in order to support the necessary course corrections as your business requirements change.

Related link: ftp://www6.software.ibm.com/software/developer/library/ws-reliablemessaging20050…

WS-ReliableMessaging was republished on Tuesday of this week. The most substantial change was in the legal language, which grants royalty-free rights to implement. The most important technical difference is the relaxing of a restriction that used to require that a recipient keep track of message sequences beyond the receipt of a TerminateSequence message. The recipient is now allowed to disregard any straggling messages that arrive after a sequence has been terminated. For more information -

https://www-128.ibm.com/developerworks/webservices/library/ws-rmreload/

ftp://www6.software.ibm.com/software/developer/library/ws-reliablemessaging200502.pdf

Dave

Related link: https://www.forum.nokia.com/040?fsrParam=2-3-/main.html&fileID=8111

The 3GSM World Congress has just started again in Cannes and this week sure will be packed with heaps of news about upcoming mobile phones, technologies and services. There have already been a couple of interesting announcements regarding the ever-expanding spread of SVG Tiny on mobile devices. Sony Ericsson kicked it all of by announcing two new SVG-equipped phones shipping later this year, adding to the numerous SVG handsets that Sony Ericsson already shipped in 2004.

Yesterday also saw Nokia introducing the main lines of the upcoming Series 60 version 3 platform. For those who don’t already know, Series 60 is a very popular smartphone platform built on top of Symbian and shipped on phones from Nokia, Panasonic, Siemens Mobile, Samsung, Sendo and LG. Series 60 v3 will be built on top of Symbian 9, and some of the main focus points will be multimedia and location-based services. In order to support that vision, Series 60 v3 will pack up the JSR-226 APIs, allowing rendering, creation and manipulation of SVG Tiny contents. SVG is already rather popular in mapping circles and innovative location-based services based on SVG Tiny are rapidly appearing in Japan, with KDDI’s Go SVG leading the pack. You can find more details about Series 60 v3 on the Nokia Forum.

Related link: https://sourceforge.net/project/showfiles.php?group_id=21935&package_id=16608&rel…

The DocBook Project has released version 1.68.1 of the DocBook XSL stylsheets. This release fixes a packaging bug in the 1.68.0 release that made the Java XSLT extensions unusable. It also adds localization support for Farsi and improved support for the XLink-based DocBook NG db:link element.

https://sourceforge.net/projects/docbook/

Related link: https://specs.xmlsoap.org/ws/2004/09/policy/

This is just kind of an FYI -
In order to provide a vendor-neutral place for the publishing of co-author collaborations of Web Services specs, we the co-authors of WS-Policy have placed copies of the September ‘04 versions of these specs out at https://specs.xmlsoap.org/ws/2004/09/policy/

Xmlsoap.org is where the schemas for SOAP 1.1 and WSDL 1.1 live, so it’s already perceived as a “safe” location for published specs/data. The expectation over time is that other WS-* specs will be posted to xmlsoap when it makes sense, but not necessarily all of them. They will also continue to be available on the individual authors’ web sites.

I guess it makes it seem less alarming when other specs that are in standards bodies reference these “non-standard” specs.

Dave

Related link: https://abcnews.go.com/Business/print?id=88655

Slashdot picked up a piece wondering if the “first hints of rot” were in the air at Microsoft, which made me think about Microsoft when I first liked their products years ago and what I’ve found lately.

I guess it’s fair to say that I’m returning to Microsoft subjects after
working in fields where they mattered but weren’t the universe, and things
feel very different. When I last followed them closely:

• Internet Explorer 4 was pretty much a revolution when it arrived, bringing
  huge new scripting functionality. IE 5 for the Mac made similar
  improvements on the CSS side. Now that same browser core is a giant dead
  weight holding down the Web’s capabilities.

• Windows NT Server was stunning not so much because of its capabilities, but because it combined stability with an interface ordinary non-CLI-worshipping humans could understand. I really angered a Novell partisan friend of mine by saying NT would take over what Novell was doing then. (My friend now works at Novell, where he is very happy lately thanks to the Linux work and Mono giving them a new burst of excitement.) Windows 2003 Server rarely feels as interesting, though, and I long since stopped keeping Windows servers at home. The interfaces are kludgey, and at my level of use dedicated appliances (often Linux-based) make more sense.

• Even Office, which I’d been using for years, having pretty much lived in Word during college, still had a lot of new tricks up its sleeve. While I still count Word 5.1 for the Macintosh (~1992) as the most overall usable version of the product, they made some major steps in Office as it became a Windows standard. Access 2.0 was an amazing leap forward, IMHO, and the 97 suite made some big changes in standardizing VBA across the line, but since then change has been largely incremental. (And yes, the XML support is a
  thin candy shell along the outside edges. When it goes deeper, as in Word, it generally breaks.)

Today, I see a lot less interesting going on, though there’s still some interesting work going on there, some I’d even bless with their hallowed word ‘innovation’:

• InfoPath took an XSLT parlor trick (making it two-way) and turned it into a forms application. A forms application with a confusing marketing picture, yes, but…

• SharePoint may be the first sizable improvement in how people use Office since email became ordinary. It’s not rocket science, but it manages some complex tasks cheerfully.

• The .NET Compact Framework and Pocket PC generally intrigue me, though it’s hard for me to say that it’s very different from J2ME with a slightly more native-environment-friendly twist.

I’m looking forward to seeing what they have for show and tell in the future, but I can’t say at this point it feels to me like
they’re thriving. Their sheer momentum should keep their space open for a while, however!

What’s the most exciting thing Microsoft is doing today? (Seriously!)

Related link: https://sourceforge.net/project/showfiles.php?group_id=21935&package_id=16608&rel…

The most signficant new feature in this release is probably the addition of support for side floats, margin notes, and custom floats in FO/PDF output.

Heres’s the full list of changes for the release

Related link: https://www.sonicsoftware.com/news_events/seminars/soaforum_sonic_winter05/index.…

Over the past several months I have been speaking in a series of SOA Architect Forums that we (Sonic) have been conducting across the US, Europe, and (coming soon….) Japan. Co-sponsored by BearingPoint and Sun, the forums have been drawing small crowds ranging from 25 – 100 people, all senior level enterprise architects. In addition to listening to a presentation and discussion on the architectural components of an ESB, the format of the half day forum also includes an interactive roundtable discussion where have a panel that includes solution architects from BearingPoint, Sun, and Sonic.

As panel members, we are there to provide some of our own experiences with the challenges of building enterprise wide SOAs, but the best discussions by far have been the ones where the discussion moves out into the audience and stays there. These sessions have been very enlightening in that a group of architects are interacting with their peers from other organizations, and sharing with each other the issues that they are encountering.

Here is one of the many burning issues that have come out of the discussion - IT organizations are assembling teams of architects with the goal of building architecture for the future that will be in place for at least the next 10 years. Most architects intuitively understand the value of building a SOA, but they are struggling with how to associate the business value of building a SOA, and explaining that to the business managers who control the budgets and provide funding for such initiatives. While there doesn’t seem to be one good answer that fits everyone, the various discussions seem to reduce it down to these main points:

-Enterprises need the business agility to react to ever-changing business requirements, and continually implement new programs to attract and retain customers.

-In support of this, business processes need to be automated, streamlined, refined, and measured.

-The underlying IT infrastructure which supports those business processes need to be flexible and capable of adapting to change. Continued measurement of success means that the change needs to happen in real time and results need to be measured in real time.

-IT systems contain lots of existing functionality in the form of in-house business logic that represents domain expertise that is germane to the particular business you are in. Commercial Off The Shelf (COTS) applications contain business logic that automates common business functions, such as HR management, Accounting, and Enterprise Resource Planning (ERP). Most installations of these systems represent heavy investments in licensing, installation, consulting, and custom tailoring to meets the individual needs of an organization.

-The key to realizing the business benefits of building a SOA is to recognize the ability for a SOA to be able to leverage existing application assets, and expose them using service level abstractions that are loosely coupled, and standards based. New automated business processes can be built more rapidly by stitching together composite applications that invoke these services and combine them with new business logic that is also exposed through service level interfaces. This is what forms the basis of a SOA. The key to tying this back to the business benefits is how it how well the SOA infrastructure is capable of being configured, streamlined, and measured. Implementing new programs to react to competitive pressures can only be effective if they can be done in a timely manner. New initiatives to attract and retain customers usually have a direct measurable impact on the business. These programs can only be proven successful if they are capable of being measured in real time for their effectiveness, and also capable of rapid course corrections based on the results of the measurements.

In summary, the title of this is perhaps a little backward. Its not so much about how to extract business value from SOA, its more about how to extract value from the assets that you have in place. A SOA can be the architectural approach to help make that happen.

That’s the net/net of the discussions on this subject so far. I would love to hear your opinions on this as well….
Dave

Related link: https://amazon.com/prime

Okay, so maybe “perils” is too strong; but Amazon — in my book, the exemplar for online retail — is having some trouble with its newly announced Prime program. Which is to say: Amazon’s newly announced Prime program is dead on arrival!

What is Prime? It’s a $79 buy-in to really good shipping deals. You get 2nd day delivery free on all qualifying orders and overnight delivery for $3.99. And since 90% of what I buy from Amazon — new books — qualifies, this seems like a great deal for me. Do the math: I order about 30 or 40 times per year from Amazon, paying about $7 or $8 per order for shipping. That’s roughly $300 per year, and I almost never choose 2nd day — overnight is even more rare.

Even though I never choose overnight, I’m often tempted to choose it, because sometimes I want that new Zizek or distributed algorithms book, and I want it NOW. Using Prime, I can save lotsa money by using free 2nd day delivery, and occasionally I’ll spend $3.99 for overnight. Hell, if I always choose overnight, I’ll still save money.

So where do I sign up?

Apparently, right now, nowhere. Lemme clarify that: I signed up about 30 seconds after reading what Prime was last week, and then I waited and waited and waited. The $79 transaction never went through and I thought my credit card had been declined, though that seemed unlikely. Since I had a stack of Harvard Business Review books I wanted to buy, I got a bit anxious and called Amazon this morning, something I’ve only done two other times since 1996.

During the course of this call I learned that Amazon’s Prime program, while still being advertised on the front page in a big splashy form, doesn’t work. There are “technical problems” and I will get an email “when we have them ironed out”.

How embarassing!

In all fairness, I suggested to the Amazon CS rep that I wanted an upgrade on free shipping for the order I was about to place, and he quickly arranged that for me, which is a good way to ameliorate my frustration. A quick search of Technorati surprisingly showed no one talking about this yet — or is it flakey too? — so I thought I quick weblog post was in order.

Seriously, Amazon is an amazingly well run organziation from my point of view as a tech-savvy frequent customer. Werner Vogels — one of my fav techie webloggers — just became Amazon’s CTO, and I know lots of Amazon geeks who know their stuff cold. I can wait till Amazon gets the kinks worked out of Prime; but what I’m really curious about is whether it’s a technical — i.e., computer software or hardware — problem or whether it’s a distribution or shipping system problem. Unless an insider weblogs it, I doubt we’ll ever know.

But given that Amazon is similar to Google in this respect — namely, that both companies key to success lies in an area most people don’t think about… for Google, it’s massive operations research; for Amazon, it’s distribution, warehousing, and shipping systems — it’s surprising to see them stumble in a core competency.

I applaud the Prime program because it shrinks one of online retail’s disadvantages vis-a-vis bricks-and-mortar retail (the “I want it ASAP” aspect of commodity fetishism), but you have to wonder how this embarassment of announcing a system that doesn’t work slipped through their fingers?

Amazon’s Prime program is interesting, except for the fact that it doesn’t WORK!

Related link: https://sys-con.com/story/?storyid=48035&DE=1

Since releasing my latest book, Enterprise Service Bus (O’Reilly Media, 2004), I have been doing a fair amount of visiting corporations, conducting seminars and architect forums, and generally discussing with enterprise architects the subject of enterprise service-oriented architecture (SOA) and how an enterprise service bus (ESB) backbone can be leveraged to provide a framework for an enterprise SOA. Along the way, I have been asked many questions about the nature of an ESB. I have also fended off some misconceptions that have been growing in the general IT population regarding what an ESB is and when, where, and how it can be used. I have gathered together the most popular questions and misconceptions, and offer some clarity in the form of a “top ten” list.

The full article has just been published in Web Services Journal at -
https://sys-con.com/story/?storyid=48035&DE=1

Dave

Related link: https://www.omnigroup.com/applications/omniweb/

Out of curiosity a week ago, I decided to download OmniWeb and try it out. I got there because after reading a little bit about my latest favorite application, Delicious Library, I realized that the two founders of that new company used to work on user interfaces development at Omni, the software house that makes OmniWeb. My interest was also piqued by the idea that a non-free (the license is $29.95) browser could actually survive past one release cycle. Last but not least, I had also heard that these guys had dumped their previous HTML rendering engine and started using Apple WebKit, thus focusing mostly on bringing some innovative user interface features to the mix. I had to try that, and after a week of use I’m not disappointed. Here are a few of my favorite bits about OmniWeb.

Form Inputs.
This one is my single favorite feature. Since I’ve created SVG.org, an SVG community website, I spend a lot of time typing into text areas. Up until now for me, that meant poor editing capabilities and mistakes posting or erasing things I had just spent quite a lot of time typing. Dang! In OmniWeb, all form text areas have a little + button in their top-right corner. Pressing that little button slides a new window out of the text area and allows you to type freely, with any text you type in sync with the one in the text area. When you’re done writing, just close the window and you’re done. That new text input window also allows for importing text from some file on your hard drive too. Oh, also OmniWeb has the Mac OS X spell checker working in text areas and editing windows, so now you can make sure you typed something correct. I just used these features to write this blog entry, it’s really great.

Source View.
I love that one too. When you view the source of a document in OmniWeb, you get a nice new window with the source content with syntax highlighting, buttons to minimize or expand the tree structure and also a way to edit the source and reload the page with the modifications you just made. I use this feature sometimes when some websites have truly offending HTML that WebCore can’t handle too well. For instance, my TV program website outputs really dodgy HTML for its ads, and sometimes with Flash ads the pages don’t get displayed completely, and I can’t see the content I was looking for. With the source editor of OmniWeb, I simply do View Source, then ask for a nicely formatted source view and get rid of all the offending <embed> elements and nasty scripts. Once I’m done, I just press the reformat button and I’m all done. That saved my butt quite a few times already.

Tabs.
I won’t expend too much on this one because I think the way OmniWeb does tabs is more subject to personal appreciations than any other features I highlight here. OmniWeb doesn’t do tabs like most browsers (Safari, Firefox, Camino) do. Instead of having a bar with page titles on top of your page view, you get a Mac OS X drawer added to your browser window with snapshots of what each page looks like, and a status of whether the bar is fully loaded yet. The snapshots really help in finding your page quickly. There are other nice features, such as tabs snapshots reordering, so you can put two pages side to side to navigate faster using the tab-switching keyboard shortcut. You can also drop any document that OmniWeb can display in the tab drawer in order to have it opened in a new tab. And if you’re not too fond of snapshots, you can simply choose to have a list view. Cool.

Workspaces.
I have been doing quite a lot of work on HTML documents lately editing specs. When I do that, I tend to work on several web pages at the same time, as specs have several chapters, or I have different archived emails showing in tabs to keep track of things I need to do. OmniWeb allows me to save the state of my browsers as an environment, so I can easily have all my tabs re-opened when I need. Now I have 5 different environments, one for each of the 5 different projects I’m working with at the moment. This really is a time-saver.

Per-site preferences.
Like most browsers, OmniWeb allows me to setup a few global rules for viewing web pages, such as appearance, ad-blocking, security settings, etc. On top of these default rules, for each website I’m visiting, OmniWeb lets me easily customize these same settings by the click of one button that I placed next to the address bar. I use that a lot because some sites have tiny fonts that I want bigger, or when I want to actually see ads from a website I enjoy and want to support, or most often when a website sends the wrong content encoding and using the basic settings makes the page unreadable.

Conclusion.
I’m sure there are other features that I haven’t explored yet that makes the purchase of OmniWeb worthwhile, for instance I haven’t tried using OmniWeb as an RSS reader yet, nor did I try to customize search shortcuts. But these features alone are sufficient to convince me I can hardly go back to my previous browser (Safari in my case) and shell out the $29.95. Do try this at home!

Are you using OmniWeb? Have you tried it? What’s your preferred browser on Mac OS X?

Related link: https://conferences.oreillynet.com/cs/os2005/create/e_sess

The general call for papers for OSCON talks a bit about some XML and Apache XML things the conference organizers (myself included) would like to hear about, but I’d like to suggest some general trends on which I’d like to see presentations:

• OSCON has focused more on Open Source than Open Data historically, so talks aimed directly at programmers are likely the most effective here.
• That said, I’d like to see some talks which look at how Open Source and open XML-based data formats can reinforce each other. It feels to me like XML has brought with it many more opportunities to blur the open/proprietary line.
• XSLT seems to remain mysterious to a lot of programmers, and it would be good to see talks which focus on integrating XSLT with other (Perl, PHP, Java, etc.) processing.
• Half-day quickstart tutorials which give programmers what they need to get started with various XML technologies in a compressed time frame would be appreciated.

We’ll be taking proposals until February 13th, midnight PST.

Related link: https://weblog.infoworld.com/udell/2005/01/27.html#a1159

Do you know of other uses of addressing specific points in audio files to create a new version of a work?