Thinking Clearly .

This is not a post expressing my long standing and ongoing concerns (yes they are both “long standing” and “ongoing”...they stand on a very long conveyer belt, ok?) with both the fundamental presumption of the Technical Architecture Group and the things they actually do. I’m not going to explain the fallacy of Argumentum ad Architectural-Blather-I’ve-Pulled-Out-From-My-Ass-Compartment. No, this post is all about coping. Specifically, coping with argumentum ad ABIPOFMAC.

My current thought is to replace the annoying terms and phrases with a harmless or comforting word associated with a pleasant image or thought. The word doesn’t have to be precise: I’ve selected “puppies” (and I’m not a dog person!) So instead of the “Technical Architecture Group”, I see “Technical Puppies Group” or, the “Pile o’ Puppies” (POP). I applied this technique to a recent post by a POP member to the HTML Working Group’s list. Here are some key excerpts:

Puppies of the POP believe that the ping attribute as proposed in HTML5 may have a deep impact on the puppies of the Web itself. Accordingly, the purpose of this bark is to invite the wider puppy community to discuss these piddling issues on on[sic] puppy mailing list www-POP@w3.org (archives at [5])—the issues ruffed appear to have bones beyond HTML5[ed. e.g., like on THE WEB ITSELF!!!], which is why we would like to broaden the laps, and at the same time to focus on the wider puppy questions of how HTTP, HTML and puppies cuddle. We also note that to serve as an umbrella for its own licking of these questions, the POP has re-opened its sniffles “whenToUsePuppies-7” [6].

Note: our puppies here is specifically to involve the Web Puppy community in the discussion of these puppies. ...
Noah Mendelsohn
For: the W3C Pile o’ Puppies

Ok, it’s better but not really great. But, really, there’s only so much one can do with a paragraph that includes, with all seriousness, the phrase, “may have a deep impact on the architecture of the Web itself”. The Web….itself. When you read those stirring words themselves, your choice itself is stark: either you hear solemn music itself welling up in the background itself and prepare yourself itself [sic] to ponder Serious Matters (themselves)...or you hear puppies piddling.

Embracing the piddling, my friends.

No puppies were harmed or even encountered in the making of this post.

Whatever you do, do NOT try the old “in bed” trick. Unless I don’t like you, in which case, by all means read the phase “The Technical Architecture Group….in bed” over and over again.

This post constitutes fair warning that if you try to argue a point with me by appeal to Semantic Web puppies, I will tend to giggle and have a hard time taking you seriously.

Apropos of nothing: Support the writer’s strike. Vote Robot Overlords! (Like you have a choice!)

One thing that really, really annoys me is clueless OWL haters. OWL isn’t perfect, of course, and it’s certainly not the best tool for many tasks. In fact, we spend a lot of our time talking to customers about those cases where OWL isn’t applicable, if only because we love to undersell and overdeliver. But there’s good criticism, and then there’s clueless drivel—all too often, I hear the latter instead of the former.

In my view, too many SemWeb advocates fall into this trap of clueless OWL hating, most often tinged with rather a bit of anti-academic, anti-intellectual know-nothingism. This really annoys me, not least because several of us in C&P, got our starts in academia; and in academia, and since then, we’ve been relentlessly focused on solving real world problems with our tools.

In other words, this anti-intellectual, OWL-is-impractical crap annoys me because it’s so trivially false. That is, what makes the OWL haters so tiresome is that, more often than not, they simply don’t know what they’re talking about. They haven’t put in the time or energy to actually learn OWL’s (and Description Logic’s) actual warts, problems, and faults.

The standard claim runs something like this: “I’m no expert, and I’ve only just started reading about DL and OWL, but I’m pretty sure that it’s useless and is really holding the SemWeb back with its academic-centric focus”, etc. I’ve read that kind of claim dozens and dozens of times on weblogs and in email over the past few years. Couldn’t they at least find some new crappy line?

Ultimately I suppose none of this bad advocacy really matters much, since whether or not any of this technology takes off or not is more a function of big, structural forces rather than what any particular people do or say. But, speaking only personally, it gets old to hear people bashing stuff that they haven’t even taken the care to properly understand.

Say what you want about academia and research communities, but they are places where the priority of understanding to criticism—that is, you don’t evaluate anything until you really understand it—is still practiced. That’s one of the scientific virtues that even self-appointed advocates and marketeers would do well to emulate.

I see Dan has converted the Witch argument to N3 and used its proof generation tools to output a proof (btw, Dan, the OWL version was a solo effort by me and I guess you’ll have to come to our actual weblog to see who I am :)). (BTW, even though I linked to it, I should mention explicitly that the original is due to John Ioannidis.)

I’m jotting up the tableau version of the proof (but it’s a bit tricky, pedagogically since if I use a linear proof format, then it doesn’t really correspond to what, e.g., Pellet does, but if I use a completion graph approach I gotta go graphical). However, Dan’s post reminded me that SPASS (and MSPASS) will generate (roughly, resolution based) proofs and have web interfaces. (These proofs are meant, I think, to be checkable.)

So, following the SPASS tutorial, I got this:

begin_problem(Burn_the_Witch_Argument).

list_of_descriptions. name({*Burn the Witch Argument <strong>}). author({</strong> Bijan Parsia <strong>}). status(unsatisfiable). description({</strong> Formalization of the Burn the Witch Argument*}).
end_of_list.

list_of_symbols. functions[(girl,0), (duck,0)]. predicates[(Burns,1),(Woman,1),(Witch,1),(IsMadeOfWood,1),(Floats,1),(SameWeight,2)].
end_of_list.

list_of_formulae(axioms). formula(forall([X], implies(and(Burns(X), Woman(X)), Witch(X))), 1). formula(Woman(girl),2). formula(forall([X],implies(IsMadeOfWood(X), Burns(X))),3). formula(forall([X],implies(Floats(X), IsMadeOfWood(X))),4). formula(Floats(duck),5). formula(forall([X,Y],implies(and(Floats(X), SameWeight(X, Y)), Floats(Y))),6). formula(SameWeight(duck, girl), 7).
end_of_list.

list_of_formulae(conjectures). formula(Witch(girl),8).
end_of_list.
end_problem.

If you paste this into the SPASS interactive web form, and add -DocProof in the options field, you’ll get a bunch of stuff including the proof:

Here is a proof with depth 3, length 15 : 1[0:Inp] || -> Floats(duck)*. 2[0:Inp] || -> Woman(girl)*. 3[0:Inp] || -> SameWeight(duck,girl)*. 4[0:Inp] || Witch(girl)*+ -> . 5[0:Inp] Floats(U) || -> IsMadeOfWood(U)*. 6[0:Inp] IsMadeOfWood(U) || -> Burns(U)*. 7[0:Inp] Burns(U) Woman(U) || -> Witch(U)*. 8[0:Inp] Floats(U) || SameWeight(U,V)*+ -> Floats(V). 9[0:Res:7.2,4.0] Woman(girl) Burns(girl) || -> . 10[0:MRR:9.0,2.0] Burns(girl) || -> . 17[0:SoR:10.0,6.1] IsMadeOfWood(girl) || -> . 18[0:SoR:17.0,5.1] Floats(girl) || -> . 20[0:Res:3.0,8.1] Floats(duck) || -> Floats(girl)*. 21[0:SSi:20.0,1.0] || -> Floats(girl)*. 22[0:MRR:21.0,18.0] || -> . Formulae used in the proof : 5 2 7 8 4 3 1 6

Neat!

SPASS is a full first order logic theorem prover. Our translation into OWL DL (ALC really) shows that we don’t need full FOL for this. MSPASS tweaks SPASS so that it effects a decision procedure for (various) DLs. I did a MSPASS DL variant of the argument as well (wish I had an tool to convert to that format from OWL; oh, if you want to save it to disk, you should strip off the ”.txt” and put a dot before the “dfg”.). You can test it with the MSPASS web interface (which will show you the various translations back to FOL).

Philosophically, I’m remain skeptical about the general value of proof generation (at least for exchange, e.g., for PCA like tasks), especially for scalable, decidable logics. Basically, the proofs can be expontential in the size of the input, and the input can be large. For decidable logics with optimized reasoners, for many things, an asserted justification (i.e., a minimal set of axioms from the KB sufficient to entail the conclusion) might be more than sufficient. There’s a complex story here, of course, but if your proof checker isn’t reliable (Dan said he was still finding bugs :)), then even using it to verify is a bit tricky. Proof checkers aren’t always easier.

(Sigh. I’m playing with Diigo and accidently hit the “back
button” key and thus lost the post. Grr. The first thing any in browser
blog tool should do is make sure you don’t lose work!

Continuing off line.)

Cerebra has been bought out by
webMethods. Cerebra was based on University of Manchester
tech, that is, Ian Horrocks’ (my current line manager and an all around
terrific person) FaCT reasoner. This is potentially great news for the
Semantic Web and Semantic Web Services crowd, that is, if the Cerebra
folks can pull something off that gets real recognition. Could be much
more legitimizing than even the Oracle RDF support.

There wasn’t a lot of information out there about the deal (although, I
have inside sources; not as inside as I would like). Predicably, most
of the press reports were twaddle. However, some twaddle stands above
the crowd—so much so that I felt compelled to pick at it bit by bit.
This also gave me a chance to test out the Diigo
extension for FireFox. The key feature for me is the ability
to make out of band annotations on selections of web pages (a la Third
Voice, Annotea,
or the venerable CritLink)
with the nice twist that you can make a weblog post based on the
selections and comments. I actually tried to do this back in 2000/2001
using Annotea, but the experiment fizzled on a Bush speech. (It would
have worked if I’d perservered. Mostly, I got sick of wrestling with
Annotea’s RDF.) I would like to make it easier to toggle between the
blog post, the extracted snippet, and the in line annotation views.

The rendering is rather sucky, though. And was sucky to clean up. And I didn’t get it all that clean. Plus, the source now has an annoying mix of HTML style (who knows what WP will do to it.

I also found myself snippetting first, then commenting, mostly because
the pop up commenting dialog was flaky. Back in the DailyChurn/
DiaWeblogBot
days, the commentary tended to be interleaved. But that, I think, was
because of the strengths and limitations of IRC and the bot: we couldn’t interleve
comments unless we interleaved the commenting, and the set up
wasn’t nearly as annoingly flaky as the Diigo extension. Still, fun
stuff.

All quotes are take from this article: WebMethods buys firm to add
semantics to SOA from the Computer Business Review.

Staff Writer

The byline says “Staff Writer”, whereas “underpaid and
overworked” staff writer is probably more appropriate. If I were this writer, I’d be
most grateful for the concealment.

Evoking thoughts of the “semantic web,” webMethods Inc has acquired Cerebra Inc for an undisclosed sum to incorporate its technology into the next version of webMethods’ SOA fabric.

So, why does this evoke
thoughts of the semantic web? If
you look at the vast majority of reports on the acquitition, you’ll
find no mention of the Semantic Web, and only a few references to OWL.
webMethods certainly didn’t say anything about them. Note that
“undisclosed sum”, which will pop up later. And shouldn’t the name of
the product, Fabric, be captialized, etc.?

The acquired company, which numbers all of 16 employees, adds the ability to infer relationships between metadata. That is, if A relies on B and B relies on C, Celebra’s technologies concludes that A and C also have an interdependent relationship.

That “which” clause is
very strange…what difference does the number of employees make? If
this is going to be part of an analysis that Cerebra had problems or
was marginal, shouldn’t there be some analysis to this effect instead
of innuendo? I’m willing to believe (indeed bet) that Cerebra had
problems, but these could be for a number of reasons. Obviously,
webMethods felt it was worth grabbing it. The rest of the sentence is a
mess too. To what does Cerebra add an ability? And let us all shudder
together at “relationships between metadata”. Of course, the
clarification decends even further. First, to take a transitive
relation (implicit) between…what? Metadata? Entities? What what what
are A, B, and C? And what the hell is the conclusion? Surely we
shouldn’t conclude that A and C are interdependent.
After all, it is A that relies on C, not the other way around (for all
we know).

It works the same way with transforms, making it possible to draw more conclusions about which services could be reused for a new or newly orchestrated business process. And it could be used for gauging the impacts of a change in a particular service or business process.

It is strange to define
‘infer’ but not ‘transforms’, especially when it’s not clear what is
meant. I guess the idea is that if you make a new composition, you
could derive things about it. But, really, while in some sense true,
this is so vague as to be useless.

“Business analysts won’t have to navigate through complex hierarchies to reuse services,” explained webMethods CTO Marc Breissinger.

This is quoted everywhere
and it makes no sense! It is after all compatible with this
continuation of the sentence, “Instead, they’ll have to extrac their
own teeth with rusty pliers in order to complete the sacrafice to Bael.
That, or their children. Bael isn’t going to cough up the right service
without SOME sort of bribe.”

The technology utilizes several W3C standards associated with the Semantic Web, including Web Ontology Language (OWL) and the Resource Description Framework (RDF).

What happened to the
“the” for “Web Ontology Language”? I don’t get how the “technology”
“utilizes” (ugh) the standards. Is this helpful? It’s interesting that
the writer gives this hint (many don’t, including the webMethods’ press
release), but I would hope for a bit more coherency and reasonable
explication.

However, although they have been officially ratified, neither standard has entered wide use, given the underwhelming response to make the web itself more “semantic.”

There’s definitely a
comma splice at the end there. Presumably, there is a connection
between the lack of “wide use” and the “underwelming response”. (First,
let me note that “wide use” is a funny term thrown around a lot. There
was a thread on the RIF list where people were claiming that in order
to meet the “critical success factor” (ugh) of “widespread adoption”,
we had to support existing rule vendors. Well, what’s “widespread”?
There’s no way that any rule language is going to be as widespread, on
any metric, as HTML, XML, Javascript, Java, XPath, C#, or MacOS X (ok,
maybe the last; though that’s millions of seats).
Of course, to be a success does not require
widespread adoption. Vertical markets can sustain a lot of businesses,
open source projects, or even user communities. Heck, just interest can
sustain a user community. Again, this sentence is mostly incoherent.
What is it to make the web itself more semantic?
XML and Web Services can be seenn as trying to enrich web
represenations (of various sorts). They have received an enthusiastic
reception.

Consequently, while use of these standards might provide a degree of interoperability with semantic frameworks that operate over the web, for now that remains a big if.

What is the “big if”? The
interoperability? The degree? What what Of course, this is a weird
point. The point should be that the fact that they consume OWL won’t
necessarily mean that there’s lots of OWL data to consume, since its
not widely used. The right analogy would be with RELAX-NG. If someone
bought out a company based around RELAX-NG, it wouldn’t be a selling
point that every company is using it to describe their web service
inputs and outputs. They aren’t. So, that’s not a good reason to buy
that technology. (Of course, if the company could convert XML Schemas
into RELAX-NG internally and do something extra cool with it, that’s
fine. Or any of a number of other things could work.) But this surely
isn’t a point of doubt about the wisdom of the
buy out. Cerebra always was after high end, enterprisey markets, and
webMethods certainly doesn’t care if there’s no OWL out there. The
question is whether you can use the reasoner (or other stuff) to do
more than you can do with out it. This is exactly what we did with the reduction
of WS-Policy to OWL-DL. We don’t want people to switch
to OWL-DL, or expect that the value of the
conversion is resusing the tons of OWL documents out there. The value
is the better analysis tools you get.

Instead, webMethods prefers to emphasize that this is not about the semantic web, but instead, making services networks themselves more semantic or meaningful. These standards are invoked under the covers, and users do not need to know them.

Without a reasonable
diagnosis of the “underwhelming response”, how do we know that users
want the “services networks” (what are these?) more “semantic” (or
meaningful), or rather, are willing to do the work to properly “use the
standards” even under the covers? Heck, if this works in house, why not
for the Web as well?

What’s interesting is that the technology recalls similar attempts to craft inference languages during the abortive emergence or artificial intelligence technologies 20 years ago.

I like the typo
“s/or/of/”. However, this is, yet again, a very puerile appeal to the
AI winter. Grow up. This is not insight
providing. (I shouldn’t have to explain this, but there are multiple
fallacies involved in the typical appeal to the AI winter. See my
article on Prolog and RDF for a very quick, facile, gloss.)

There were many problems with early AI, among them weak hardware and primitive techniques for so-called “garbage collection,” that eliminated irrelevant associations.

This is the bit that
caused me to rip into the article. Garbage collection. So-called
garbage collection. Garbage collection, like, that thing we find in
such obscure and failed technologies as Java. The best part is claiming
that GC worked, primarily, at the semantic level,
that is, that the job was to prune “irrelevant” associations
(irrelevant to what, one wonders!). Even though there was a lot of
close associating and confusion between logical and physical levels (to
rip off DB terminology), I don’t know anyone who made this
mistake. After all, (pointer/reference) reachability and relevance are
at best tenuously related.

But the biggest problem of all was that classic AI applications required complex, specialized languages because the rules or inference bases had to be built by hand.

Sigh. Repeat thrashing.
Whine. Point out that the sentence contains a non sequitur, or is a non
sequitur, or, even better, sucks.

The difference this go-round is that the Cerebra technology being acquired by webMethods is fully automated, and won’t require customers to learn specialized languages.

Now this
is trivially obvious crap. As far as I know, Cerebra has no automated acquitition
tech, nor any expertise. But isn’t this a red herring? Most Web
Services markup is manual or close to manual. (Sure, you can generate
WSDL from code, but the WSDL only contains information that was in the
code. It’s not the results of learning or other
generalization. So, to reap benefits, you must do work. Surpise,
surprise.

Instead, it will operate using wizards that either automatically define semantic relationships, or provide the means for users to specify them.

Laughter. Ringing
laughter. It’s totally automatic, via that fully automated mechanism of
wizards, which may require the users to specify stuff. That is, it
requires human work. By the way, Staff Writer,
all the old AI systems/expert systems had tons of tools to ease
acquitition.

Initially, webMethods plans to incorporate the technology
into its SOA Fabric product, where it will be used for spotting
opportunities for reuse ore provide grist for change impact reports. It
could peruse listings residing in service descriptions in local or
remote UDDI web services registries.

So we’ve gone from
random, ungrounded (though groundable) skepticism to breathless, inane
cheerleading. Cerebra had software that could, in any meaningful sense, peruse listings? No. I think not. This is just
hype, and stupid hype. No one from Cerebra would claim this. Silly.

The 16-person company, based in Carlsbad, California, was acquired for an undisclosed, modest sum, and the deal is already closed.

Why the repetition of the
employee count? And if the sum was undisclosed, how do we know that it
is modest? What counts as modest? My current belief is that Cerebra was
probably bought for less than the VC outstanding investment, so didn’t
make any of the founders rich. Alas, since that means I can’t bum meals
off Ian!

Sometimes, you just shouldn’t go with a ridiculoussexy acronym.

AWeSOMe is one of those times!

(Especially when you have to stretch so hard for it. “Ontologies Merging”? Please.)

Deliberately destroying civilian infrastructure is barbaric and evil. Stop it.