Categories
RDF

Web 2.0 just like Web 1.0 before we got clever

I’ve been reading some of the articles associated with Web 2.0 (Jeremy Zawodny has several dumps of these) , and I’m not sure that I’m particularly impressed with what I’m seeing. The consensus seems to be that Web 2.0 is really about lightweight services and open source functionality, but we had that at the very beginning of Web 1.0, before a bunch of people got clever.

Ten years ago the web was new and lightweight. A year or so after it was born, the web got a little heavier with CGI and business use, but still managed nicely. Then about six years ago, thanks to Microsoft and Sun, and IBM to some extent, the web ballooned out into these fat infrastructures and architectures like J2EE and ASP.Net and using bloated technology like Web Sphere.

I agree that these fat technologies are the work of people who were being clever and perhaps a bit greedy, but not very smart. And I am ashamed to admit I helped these efforts with my own, starry eyed participation. But I is all growed up now.

I now look back on the use of application servers in the companies I worked in and in all cases – all of them – there wasn’t a company or organization that needed an application server. None of them had the performance issues. It was more a matter of ego than anything else…

Hey, we’re going to be big! We have to think big! Bigger is better! And to scale we have to have all this iron just to make it work. Because we’re going to be big!

I can agree that we’re now learning that we can probably rip out the application servers from 95% of the companies that used them and replace them with something simple and lightweight and most likely open source and the companies would thrive and the applications would thrive and it sure would be easier to find people to work on the apps.

But we’re doing the same thing thing again – being clever rather than smart– with the concepts of podcasting and platforms, and the newest batch of ‘look at us, we is inventing now’. God, we just don’t want to let the glory of the dot-com go, do we? Well, I can understand why, and it’s not just about money: it’s about capturing that feeling of positive energy. Damn, those were glorious days.

Edd Dumbill writes about what is hot and not in the new Web 2.0, saying that what’s hot are intellectual property issues, transformations and data integration, and network engineering; what’s not hot are complicated web service and frameworks. I can agree, 100%. But what’s hot or not isn’t a matter of technology for technology’s sake, as much as it is our interacting with technology. Rather than huge applications and passive users, we’re looking more at a partnership with the technology, each providing 50% of the work. That’s a goodness…but it isn’t sexy, and it doesn’t turn heads.

We’re also looking at more than just a partnership between tech and people –we have to start finding some common ground with each other beyond just our accidental connection through the wires. For instance, Intellectual property law is spread out too thin between the extremes of those that believe that everything should be contained and copyrighted and controlled and those who think that everything should be free. How can we can work towards a solution that will please everyone when there isn’t any level of compromise among the participants in the discussion? There are a hell of a lot of cultural issues to work through before copyright can be effectively addressed, and the cultural shift has to occur on both sides of this fence.

I gather that Cory Doctorow believes if we just let EFF deal with all of these issues they would all go away. That we should have never let Intel et al determine what the tech industry wants. But what makes him think EFF would do any better? Power corrupts. Absolute power corrupts absolutely. Fractionalized effort at least brings in its own checks and balances. At this time, we need many efforts on many fronts – centralized efforts led to problems in the past that we don’t need to duplicate.

(I’ve dealt with the zealots in the open at all costs camp, and there’s a snowball’s chance in hell that I would say, “Oh sure, you go ahead and be my voice.” )

As for transforms and data integration, well this is one I do particularly like and hope that we’ll see more of. That’s the whole reason I tied on to RDF and OWL; it certainly wasn’t because I found the specs to be fascinating late night reading. We don’t annotate our material on the web nearly as much as we could, and if we did, we could do some amazing stuff.

Still, having a means and a method won’t help with transformations if the different business entities don’t agree on the data models underlying the business. We had EDI and other data transform and integration efforts years before the Web happened, and the problems we found weren’t so much in the technology as it was to get people to agree on what represents a basic data model of a business.

So I create a vocabulary for poetry and you create one, and they don’t agree. How do we work these through? Most used vocabulary wins? But what if the most used isn’t the best? What if the most used was supported by a bigger name than the better vocabulary? What technology helps to correct for the buzz effect? This is going to be the killer issue of the next decade: how do we support standardizations on, and promotion of, the ‘good’ data models?

But I’m not the only one to see that this issue is more one of the people than the tech. As Edd Dumbill writes in his essay:

There’s also another lesson I’d like to draw, which is about where people who believe in the fundamentally decentralized and open nature of the web should put our attention. We ought to be careful not to be seduced by the new platforms of the web. We fought long and hard not to have the web become Microsoft Internet Explorer, and we should fight equally hard not have it become Google. In the first wars, our weapons were the HTML and CSS standards, in the latter, they may well turn out to be the vocabularies and ideas of the semantic web.

I’ve no idea what the people at the Web 2.0 conference are talking about, but this is my notion of what the next web is: more of the same. The real shift isn’t in the web, but in the businesspeople’s perception of it.

Absolutely right on. But then Edd wasn’t at the conference, and neither was I, and neither, most likely, were you. So much for Web 2.0.

Categories
RDF

Emerging Tech Proposal

Recovered from the Wayback Machine.

I decided, what the hey, I wanted to put my Emerging Tech proposal online. I’m rather fond of it myself. I may actually build something on this for the upcoming IT Kitchen.

====================
Proposal Information
====================
Title: I, Poet

Conference: O’Reilly Emerging Technology Conference 2005

Type/Duration: 45m

Audience Level: General

Audience Type: This session is focused on a general audience, including technologists such as SysAdmins, developers, managers, and educators. There is enough geek to satisfy the coders; but enough speak for the rest.

Description:
As the universe of the internet expands, the inner core of the innovator compresses until now those seeking to find the newest incarnation of the web, the Semantic Web, circle around each other in a fast spinning wall that forms both a barrier to those watching from without, and a burden on those within.

In plain English, we haven’t reached the ‘Oh yeah, we need people, too’ epiphany among all of our technology efforts.

This talk focuses on the schema related innovations and the need within each for a critical mass: enough participants in the schema to generate value above and beyond each individual’s contribution. It explores the difficulties inherent with reaching critical mass for new schemas, especially as they relate to what is known as the ’small s, small w’ semantic web–the bottom up approach to the next generation of the web.

It covers several schemas that have achieved varied success in reaching critical mass, and explores what propelled each out of the hands of the geek, and into the hands of the poet.

The session also looks at what we can do to interest not only the poet, but the butcher, the baker, and the candlestick maker; without them, the semantic web is just so much hot wire.

Description Short:
The semantic web extends beyond the schemas and the wiring to run them; it also requires the participation of people more interested in finding a poem that uses a bird metaphor than on building the next generation of the web. But what lure can we build to capture a poet?

Categories
RDF

What is he talking about?

I’m not stupid and I know all the technologies and people referenced, but I read this recent article by Steve Gillmor and I haven’t the foggiest what he’s trying to communicate.

He begins about the recent fooflah with Robert Scoble and the attack of the 50 foot syndication feed, using this to launch a tirade against timed updates of syndication feeds. From there, though, he travels many odd and strangely branded paths, flowing eerily from Firefox terrorizing Office, to aggregators all timed to check for updates at the same time bringing down the internet, and finally to Adam Curry’s golden-locked croon through an iPod.

Throughout his article what Gillmor seems to be doing is trying to establish an argument that syndication feeds based on RSS need to be realtime. If this is so, then what is the relationship of the following to this premise, other than a gratuitous swipe at Microsoft for Scoble daring to be critical of RSS?

The rewards for adopting the RSS model are greater for those who lag in the current online economy. By contrast, Microsoft has little apparent incentive to destabilize Office by extending the free browser to support not just content aggregation but creation. Yet that is exactly what the competition is moving toward: an RSS console that automates the capture, consumption, and routing of strategic information.

Rather than the polling of the pull model of syndication feeds, Gillmor pushes for P2P feeds based on the BitTorrent model of using networked peers to handle the loads. In this model you ‘earn’ download time by donating an equivalent upload time. In other words, you get a stream of data equivalent to donated bandwidth. Well, cool. Of course, this only requires that everyone who subscribes to a syndicated feed now agree to be a part of a P2P network. And understands what that means. And that this works within the current weblog publishing model, where over half of webloggers don’t publish to their own servers, any may not even use their own computers to access feeds through Bloglines. And may be accessing these feeds from their phones. And…

Strategic considerations aside, Gillmore trips onto the iPod platform as an example of on-demand stream I assume, and from there segues into a confusing mish-mash of names and applications that have little relation to each other–other than they’re going to replace TV and Radio and a bunch of middle aged guys with too much money and way too much ego can finally have their own shows in both mediums.

Or as Snappy the Clam states:

See how many gladhanding, namedropping shoutouts you can find in this latest conflict-ridden (now with no disclosure!) advertorial puffball from RSS cheerleader and “tech journalist” Steve Gillmor.

Exploring new ways of delivering feeds is a good thing and should be applauded, but not at the expense of losing one’s independence from the blackhole that the RSS 2.0 community seems to be at times. Most importantly, regardless of the mechanisms involved syndication technology needs to be accessible by those who don’t live and breath RSS.

(And did I happen to mention that RSS is first and foremost just a specification for a syndication feed? Not a cure for the common cold? And that it won’t solve world hunger?)

Categories
RDF

Browser Dux or Deus or Duck?

In comments Dylan writes about having a visual RDF browser, …it would seem that a RDF Browser would be useful in traversing different distributed data as you follow connections and learn new information.. Danny Ayers also responded with:

If I have your Poet Vocabulary plugin for my browser, whenever I encounter material containing appropriate terms from that vocab those parts of the screen will go sepia-tinted and slightly out of focus.

I rather like that myself. Except not out of focus, let’s have the words pulse, as if they’re the beat of a heart of a new born bird. Or some such thing.

Sigh. How semantical.

They both do have a good point if you consider the visual tools that have been available for relational data models for years. I can’t remember the first tool I used, but the modeling technique was known as IDEF0, following an Air Force requirement.

In this technique, independent data objects were square cornered, but dependent objects were curved. Arrows were drawn to represent the relationships between the objects, and the key columns were highlighted above a solid line within the boxes. Categories had a circle above a couple of bars.

Models allowed us to look at the data and its relationships with each other, and helped us identify dependencies, as well as missing data. Typically, we would define the model to a particular normalized form, and then denormalize it for performance. In both cases, we’d create data models so that we could show a mapping for this conversion.

A key difference, though, between RDF and relational data, is that the meta-data to drive a data model is included with the data itself, so a model could actually be automatically generated from the same database that contained the data. RDF, on the other hand, doesn’t necessarily provide the meta information included within the same source as the data. The RDF namespace should have a defined schema, and this schema should provide this meta information – but there’s no guarantee this is accessible.

Still, as BrownSauce demonstrates, much about the model can be defined from what can be found, and if there’s enough to display nicely as HTML, there’s no reason that we can’t draw a bubble. Or a box, if we’re so inclined. But then that gets us back to my original question: would we want to?

One of the keys to understanding the RDF data is to have good text definitions to go with the objects so that we know what the data is all about. Unlike with our IDEF0 efforts, when we had a fairly good idea of the business context, an RDF/XML file (or other format if you’re a picky purist) is out there on the web, just hanging around and if you don’t know the context (i.e. “This is my FOAF file”), you need good definitions associated with the objects. A visual model won’t help with this, thought BrownSauce, with its text extrapolation is very helpful.

But there are those times when we start looking at merging data from the same or even dissimilar schemas, where a visualization could be a handy bugger. But it’s also much tricker than IDEF0. You see, a IDEF0 model has a basic functionality and purpose and the relationships between objects are very well known. The same can’t be said about any relationships between data discovered out on the web.

It’s not that the visualization can’t be done, but when it is done, it may not add value or useful information. Somewhat like a FOAF file for a person who claims five hundred people as close, personal friends – visualizing this, even to one or two levels will be impossible, and meaningless.

Probably about as meaningless as a friendship with someone who can claim 500 friends…and counting.

However, it could be a fun project, with interesting results. I’m always up for new toys. So who’s going to do it?

Categories
RDF

And why would you want to?

Recovered from the Wayback Machine.

Danny Ayers points to Leo who says that A generic RDF browser is not possible. He further clarifies his statement that you would need a stylesheet to render the data correctly. And this means you would, according to him, need a separate stylesheet for every schema.

Danny disagrees partially, saying:

From a random snippet of RDF/XML you can still infer quite a few things – what are properties, what are classes. Barest minimum is that you know something is to be treated as a resource or as a literal. That’s infinitely more that you get with arbitrary XML alone (you may know the datatype of something thanks to a schema, but even then you won’t know what the something represents).

If you have the RDF Schema/OWL ontology for the term then you should be well away.

So why not have visual components that reflect the RDF class system

I would assume that both gentlemen are discounting BrownSauce because, technically, it shows information about objects but doesn’t necessarily render the objects visually based on some criteria or constraint.

However, it does provide a human interpretable view of the data contained in the RDF files, based on specific rules and criteria defines as part of the data model associated with RDF. But it doesn’t render anything.

Stylesheets aside, one has to ask, why would one want this in the first place? We can’t render the data in a relational database without a program providing an interface and being knowledgeable about the business model constraining the data. Yet relational data has proven itself to have a use. Or two.

Why would we want to have an RDF browser?

Leo provides a nice example of what he means by rendered RDF data, with the FOAFNaut, an online utility that allows one to query a database of FOAF data, and then depict relationships discovered in a visual manner.

Keen. Now, why would we want to have an RDF browser?

Seriously, there is nothing unique or special to RDF than there is to any other data model that has been defined in the past; whether a data is visually rendered is dependent on the data, not the general model used to define the data. Geographical data in a relational database can, and does get used for visual models; FOAF data transformed from RDF to relational could be just as compellingly displayed.

BrownSauce gives us a way to read RDF without having to understand RDF and that, to me is sufficient. Add in a little visual sugar, with bubbles and all, and that would be nice, though not essential.

But what RDF provides that a relational model does not is a way of interrelating bits of data from one model with bits of data in another model and have it make sense without having to break either model. Not just store the data together – have it work together. And does so incredibly easily by publishing simple little text files that even the most moronic bot could consume if slightly trained.

So I create my poetry schema/vocabulary and encourage people to use it to annotate their online publications that contain poems. Someone else defines a schema/vocabulary for weblog posts, capturing information such as author and CC license and category and so on, and encourages people to use it to annotate their posts. A third person comes along and defines a schema/vocabulary for web objects that captures information such as whether the object has been moved, where to, is it obsolete, or other specific types of information going way beyond HTTP status codes. This person, again, gets people to use these vocabulary.

One file is now described by three separate schemas and a bot comes along and swoops it all up and is able to combine it because of one important factor: they all identify a specific resource with a given URI.

I then come along and ask for a poem that uses a bird as metaphor for freedom and my collected data then returns a selection of posts that reference a poem, giving the name of author of the post as well as other information, such as the name of the poem and its author, the fact that the post has now been moved to that location, and there’s a photograph associated with the post.

Sigh. The beauty of it brings a tear to my eye.

But I digress, badly, from the initial conversation point: why would we want a generic RDF browser. Beats heck out of me. I’m still trying to figure out how one achieves critical mass for these three vocabularies, much less how to render them.