Now I can simply state the following using Linked Data (hyperdata) links:
OpenLink Software's product porfolio is comprised of the following product families:We no longer have to explain (repeatedly) why our drivers exist in Express, Lite, and Multi-Tier Edition formats, or why you ultimately need Multi-Tier Drivers over Single Tier Drivers (Express or Lite Editions) since you ultimately heed high-performance, data encryption, and policy based security across each of the data access driver formats.
]]>A while back, I wrote a post titled:Why we need Linked Data. The aim of the post was to bring attention to the implications of exponential growth of User Generated Content (typically, semi-structured and unstructured data) on the Web. The growth in question is occurring within a fixed data & information processing timeframe (i.e. there will always be 24hrs in a day), which sets the stage for Information Overload as expressed in a recent post from ReadWriteWeb titled: Visualizing Social Media Fatigue.
The emerging "Web of Linked Data" augments the current "Web of Linked Documents", by providing a structured data corpus partitioned by containers I prefer to call: Data Spaces. These spaces enable Linked Data aware solutions to deliver immense value such as, complex data graph traversal, starting from document beachheads, that expose relevant data within a faction of the time it would take to achieve the same thing using traditional document web methods such as full text search patterns, scraping, and mashing etc.
Remember, our DNA based data & information system far exceeds that of any inorganic system when it comes to reasoning, but it remains immensely incapable of accurately and efficiently processing huge volumes of data & information -- irrespective of data model.
The Idea behind the Semantic Web has always been about an evolution of the Web into a structured data collective comprised of interlinked Data items and Data Containers (Data Spaces). Of course we can argue forever about the Semantics of the solution (ironically), but we can't shirk away from the impending challenges that "Information Overload" is about to unleash on our limited processing time and capabilities.
For those looking for a so called "killer application" for the Semantic Web, I would urge you to align this quest with the "Killer Problem" of our times, because when you do so you will that all routes lead to: Linked Data that leverages existing Web Architecture.
Once you understand the problem, you will hopefully understand that we all need some kind of "Data Junction Box" that provides a "Data Access Focal Point" for all of the data we splatter across the net as we sign up for the next greatest and latest Web X.X hosted service, or as we work on a daily basis with a variety of tools within enterprise Intranets.
BTW - these "Data Junction Boxes" will also need to be unobtrusively bound to our individual Identities.
]]>OpenLink Data Spaces (ODS) now officially supports:
- Attention Profiling Markup Language (APML).
- Meaning of a Tag (MOAT) in conjunction with Simple Knowledge Organisation System (SKOS) and Social-Semantic Cloud of Tags (SCOT).
- OAuth - an Open Authentication Protocol
Which means that OpenLink Data Spaces support all of the main standards being discussed in the DataPortability Interest Group!
APML Example:
All users of ODS automatically get a dynamically created APML file, for example: APML profile for Kingsley Idehen
The URI for an APML profile is: http://myopenlink.net/dataspace/<ods-username>/apml.xml
Meaning of a Tag Example:
All users of ODS automatically have tag cloud information embedded inside their SIOC file, for example: SIOC for Kingsley Idehen on the Myopenlink.net installation of ODS.
But even better, MOAT has been implemented in the ODS Tagging System. This has been demonstrated in a recent test blog post by my colleague Mitko Iliev, the blog post comes up on the tag search: http://myopenlink.net/dataspace/imitko/weblog/Mitko%27s%20Weblog/tag/paris
Which can be put through the OpenLink Data Browser:
OAuth Example:
OAuth Tokens and Secrets can be created for any ODS application. To do this:
- you can log in to MyOpenlink.net beta service, the Live Demo ODS installation, an EC2 instance, or your local installation
- then go to âSettingsâ
- and then you will see âOAuth Keysâ
- you will then be able to choose the applications that you have instantiated and generate the token and secret for that app.
Related Document (Human) Links
- OpenLink Data Spaces Official Page
- OpenLink Software Page
- OpenLink Data Spaces Wikipedia Page
- Attention Profiling Markup Language Project Website
- Meaning of a Tag Project Website
- Simple Knowledge Organisation Systems Project Website
- Social-Semantic Cloud of Tags Project Website
- OAuth Protocol Website
- DataPortability.org Website
- Semantically Interlinked Online Communities Project Website
Remember (as per my most recent post about ODS), ODS is about unobtrusive fusion of Web 1.0, 2.0, and 3.0+ usage and interaction patterns. Thanks to a lot of recent standardization in the Semantic Web realm (e.g SPARQL), we are now employ the MOAT, SKOS, and SCOT ontologies as vehicles for Structured Tagging.
This is how we take a key Web 2.0 feature (think 2D in a sense), bend it over, to create a Linked Data Web (Web 3.0) experience unobtrusively (see earlier posts re. Dimensions of Web). Thus, nobody has to change how they tag or where they tag, just expose ODS to the URLs of your Web 2.0 tagged content and it will produce URIs (Structured Data Object Identifiers) and a lnked data graph for your Tags Data Space (nee. Tag Cloud). ODS will construct a graph which exposes tag subject association, tag concept alignment / intended meaning, and tag frequencies, that ultimately deliver "relative disambiguation" of intended Tag Meaning (i.e. you can easily discern the taggers meaning via the Tags actual Data Space which is associated with the tagger). In a nutshell, the dynamics of relevance matching, ranking, and the like, change immensely without futile timeless debates about matters such as:
We can just get on with demonstrating Linked Data value using what exists on the Web today. This is the approach we are deliberately taking with ODS.
Tip: This post is best viewed via an RDF aware User Agent (e.g. a Browser or Data Viewer). I say this because the permalink of this post is a URI in a Linked Data Space (My Blog) comprised of more data than meets the eye (i.e. what you see when you read this post via a Document Web Browser) :-)
]]>If you want to explore who I know, what I read, and what I've tagged (amongst other things), all you have to do is:
Some Tools that help you comprehend what I am saying:
A query language for the burgeoning Structured & Linked Data Web (aka Semantic Web / Giant Global Graph). Like SQL, for the Relational Data Model, it provides a query language for the Graph based RDF Data Model.
It's also a REST or SOAP based Web Service that exposes SPARQL access to RDF Data via an endpoint.
In addition, it's also a Query Results Serialization format that includes XML and JSON support.
It brings important clarity to the notion of the "Web as a Database" by transforming existing Web Sites, Portals, and Web Services into bona fide corpus of Mesh-able (rather than Mash-able) Data Sources. For instance, you can perform queries that join one or more of the aforementioned data sources in exactly the same manner (albeit different syntax) as you would one or more SQL Tables.
-- SPARQL equivalent of SQL SELECT * against my personal data space hosted FOAF file
SELECT DISTINCT ?s ?p ?o FROM <http://myopenlink.net/dataspace/person/kidehen> WHERE {?s ?p ?o}
-- SPARQL against my social network -- Note: My SPARQL will be beamed across all of contacts in the social networks of my contacts as long as they are all HTTP URI based within each data space
PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT DISTINCT ?Person FROM <http://myopenlink.net/dataspace/person/kidehen> WHERE {?s a foaf:Person; foaf:knows ?Person}
Note: you can use the basic SPARQL Endpoint, SPARQL Query By Example, or SPARQL Query Builder Demo tool to experiment with the demonstration queries above.
SPARQL is implemented by RDF Data Management Systems (Triple or Quad Stores) just as SQL is implemented by Relational Database Management Systems. The aforementioned data management systems will typically expose SPARQL access via a SPARQL endpoint.
A SPARQL implementors Testimonial page accompanies the SPARQL press release. In addition the is a growing collection of implementations on the ESW Wiki Page for SPARQL compliant RDF Triple & Quad Stores.
Yes! SPARQL facilitates an unobtrusive manifestation of a Linked Data Web by way of natural extension of the existing Document Web i.e these Web enclaves co-exist in symbiotic fashion.
As DBpedia very clearly demonstrates, Linked Data makes the Semantic Web demonstrable and much easier to comprehend. Without SPARQL there would be no mechanism for Linked Data deployment, and without Linked Data there is no mechanism for Beaming Queries (directly or indirectly) across the Giant Global Graph of data hosted by Social Networks, Shard Bookmarks Services, Weblogs, Wikis, RSS/Atom/OPML feeds, Photo Galleries and other Web accessible Data Sources (Data Spaces).
So, unlike Scoble, I am able to make my Facebook Data portable without violating Facebook rules (no data caching outside Facebook realm) by doing the following:
In a nutshell, my Linked Data Space enables you to reference data in my data space via Object Identifiers (URIs), and some cases the Object IDs and Graphs are constructed on the fly via RDFization middleware.
Here are my URIs that provide different paths to my Facebook Data Space:
To conclude, 2008 is clearly the inflection year during which we will final unshackle Data and Identity from the confines of "Web Data Silos" by leveraging the HTTP, SPARQL, and RDF induced virtues of Linked Data.
Related Posts:
Writing a JDBC Driver for SPARQL is a little overkill. OpenOffice.org simply needs to make XML or Web Data (HTML, XHTML, and XML) bonafide data sources within its "Pivot Table" functionality realm. Then all that would then be required is a SPARQL SELECT Query transported via the SPARQL Protocol with results sent back using the SPARQL XML results serialization format (all part of a single SPARQL Protocol URL).
Excel successfully consumes the following information resource URI: http://tinyurl.com/yvoccj (a tiny url for a SPARQL SELECT against my FOAF file).
Alternatively, and currently achievable, you could simply use SPASQL (SPARQL within SQL) using a DBMS engine that supports SQL, SPARQL, and SPARQL e.g. Virtuoso.
Virtuoso SPASQL support is exposed via it's ODBC and/or JDBC Drivers. Thus you can do things such as:
BTW - My News Years Resolution: get my act together and shrink the ever increasing list of "simple & practical Virtuoso use case demos" on my todo which now spans all the way back to 2006 :-(
]]>Here goes:
In addition, in one week, courtesy of the Web, UK Semnantic Web Gatherings in Bristol and Oxford, I discover, interview, and employ Daniel :-) Imagine how long this would have taken to pull off via the Document Web, assuming I would even discover Daniel.
As with all things these days, the Web and Internet change everything, which includes talent discovery and recruitment.
A Global Social graph that is a mesh of Linked Data enables the process of recruitment, marketing, and other elements of busines management to be condensed down to a sending powerful beams across the aforementioned Graph :-) The only variable pieces are the traversal paths exposed to your beam via the beam's entry point URI. In my case, I have a single URI that exposes a Graph of critical paths for the Blogosphere (i.e data spaces of RSS Atom Feeds). Thus, I can discover if your profile matches the requirements associated with an opening at OpenLink Software (most of the time) before you do :-)
BTW - I just noticed that John Breslin described ODS as social-graph++ in his recent post, titled: Tales from the SIOC-o-sphere, part 6. In a funny way, this reminds of a post from the early blogosphere days about platforms and Weblog APIs (circa. 2003) about ODS (then exposed via the Blog Platform realm of Virtuoso).
]]>"The phrase Open Social implies portability of personal and social data. That would be exciting but there are entirely different protocols underway to deal with those ideas. As some people have told me tonight, it may have been more accurate to call this "OpenWidget" - though the press wouldn't have been as good. We've been waiting for data and identity portability - is this all we get?"
[Source: Read/Write Web's Commentary & Analysis of Google's OpenSocial API]
..Perhaps the world will read the terms of use of the API, and realize this is not an open API; this is a free API, owned and controlled by one company only: Google. Hopefully, the world will remember another time when Google offered a free API and then pulled it. Maybe the world will also take a deeper look and realize that the functionality is dependent on Google hosted technology, which has its own terms of service (including adding ads at the discretion of Google), and that building an OpenSocial application ties Google into your application, and Google into every social networking site that buys into the Dream. Hopefully the world will remember. Unlikely, though, as such memories are typically filtered in the Great Noise....
[Source: Poignant commentary excerpt from Shelly Power's Blog (as always)]
The "Semantic Data Web" vision has always been about "Data & Identity" portability across the Web. Its been that and more from day one.
In a nutshell, we continue to exhibit varying degrees of Cognitive Dissonance re the following realities:
The Data Web is about Presence over Eyeballs due to the following realities:
This is why we need to inject a mesh of Linked Data into the existing Web. This is what the often misunderstood vision of the "Semantic Data Web" or "Web of Data" or "Web or Structured Data" is all about.
As stated earlier (point 10 above), "Data is forever" and there is only more of it to come! Sociality and associated Social Networking oriented solutions are at best a spec in the Web's ocean of data once you comprehend this reality.
Note: I am writing this post as an early implementor of GData and an implementor of RDF Linked Data technology and a "Web Purist".
OpenSocial implementation and support across our relevant product families: Virtuoso (i.e the Sponger Middleware for RDF component), OpenLink Data Spaces (Data Space Controller / Services), and the OpenLink Ajaxt Toolkit (i.e OAT Widgets and Libraries), is a triviality now that the OpenSocial APIs are public.
The concern I have, and the problem that remains mangled in the vast realms of Web Architecture incomprehension, is the fact that GData and GData based APIs cannot deliver Structured Linked Data in line with the essence of the Web without introducing "lock-in" that ultimately compromises the "Open Purity" of the Web. Facebook and Google's OpenSocial response to the Facebook juggernaut (i.e. open variant of the Facebook Activity Dashboard and Social Network functionality realms, primarily), are at best icebergs in the ocean we know as the "World Wide Web". The nice and predictable thing about icebergs is that they ultimately melt into the larger ocean :-)
On a related note, I had the pleasure of attending the W3C's RDF and DBMS Integration Workshop, last week. The event was well attended by organizations with knowledge, experience, and a vested interested in addressing the issues associated with exposing none RDF data (e.g. SQL) as RDF, and the imminence of data and/or information overload covered in different ways via the following presentations:Download Lnks:
Jon Udell recently penned a post titled: The Fourth Platform. The post arrives at a spookily coincidental time (this happens quite often between Jon and I as demonstrated last year during our podcast; the "Fourth" in his Innovators Podcast series).
The platform that Jon describes is "Cloud Based" and comprised of Storage and Computation. I would like to add Data Access and Management (native and virtual) under the fourth platform banner with the end product called: "Cloud based Data Spaces".
As I write, we are releasing a Virtuoso AMI (Amazon Image) labeled: virtuoso-dataspace-server. This edition of Virtuoso includes the OpenLink Data Spaces Layer and all of the OAT applications we've been developing for a while.
There's more to come!
]]>Since I am aggressively tracking RDFa developments, I decided to quickly view Ivan's FOAF-in-RDFa file via the OpenLink RDF Browser. The full implications are best understood when you click on each of the Browser's Tabs -- each providing a different perspective on this interesting addition to the Semantic Data Web (note: the Fresnel Tab which demonstrates declarative UI templating using N3).
The OpenLink RDF Browser is a Rich Internet Application built using OAT (OpenLink Ajax Toolkit). In my case, I am deploying the RDF Browser from a Virtuoso instance, which implies that the Browser is able to use the Virtuoso Sponger Middleware (exposed as a REST Service at the Virtuoso instance endpoint: /proxy); which includes an RDFa Cartridge comprised of a metadata extractor and an RDF Schema / OWL Ontology mapper. That's it!
]]>New Semantic Data Web related features and enhancements include:
Note:This all happens because the OAT based RDF Browser simply makes a call to the Virtuoso Sponger's REST service which is exposed at the endpoint "/proxy" (note: this is standard with all Virtuoso Installations).
]]>On different, but related, thread, Mike Bergman recently penned a post titled: What is the Structured Web?. Both of these public contributions shed light on the "Information BUS" essence of the World Wide Web by describing the evolving nature of the payload shuttled by the BUS.
Middleware infrastructure for shuttling "Information" between endpoints using a messaging protocol.
The Web is the dominant Information BUS within the Network Computer we know as the "Internet". It uses HTTP to shuttle information payloads between "Data Sources" and "Information Consumers" - what happens when we interact with Web via User Agents / Clients (e.g Browsers).
HTTP transported streams of contextualized data. Hence the terms: "Information Resource" and "Non Information" when reading material related to http-range-14 and Web Architecture. For example, an (X)HTML document is a specific data context (representation) that enables us to perceive, or comprehend, a data stream originating from a Web Server as a Web Page. On the other hand, if the payload lacks contextualized data, a fundamental Web requirement, then the resource is referred to as a "Non Information" resource. Of course, there is really no such thing as a "Non Information" resource, but with regards to Web Architecture, it's the short way of saying: "the Web Transmits Information only". That said, I prefer to refer to these "Non Information" resources as "Data Sources", are term well understood in the world of Data Access Middleware (ODBC, JDBC, OLEDB, ADO.NET etc.) and Database Management Systems (Relational, Objec-Relational, Object etc).
Examples of Information Resource and Data Source URIs:
Explanation: The Information Resource is a conduit to the Entity identified by Data Source (an entity in my RDF Data Space that is the Subject or Object of one of more Triple based Statements. The triples in question can that can be represented as an RDF resource when transmitted over the Web via an Information Resource that takes the form of a SPARQL REST Service URL or a Physical RDF based Information Resource URL).
Prior to the emergence of the Semantic Data Web, the payloads shuttled across the Web Information BUS comprised primarily of the following:
The Semantic Data Web simply adds RDF to the payload formats that shuttle the Web Information BUS. RDF addresses formal data structure which XML doesn't cover since it is semi-structured (distinct data entities aren't formally discernible). In a nutshell, an RDF payload is basically a conceptual model database packaged as an Information Resource. It's comprised of granular data items called "Entities", that expose fine grained properties values, individual and/or group characteristics (attributes), and relationships (associations) with other Entities.
The Web is in the final stages of the 3rd phase of it's evolution. A phase characterized by the shuttling of structured data payloads (RDF) alongside less data oriented payloads (HTML, XHTML, XML etc.). As you can see, Linked Data and Structured Data are both terms used to describe the addition of more data centric payloads to the Web. Thus, you could view the process of creating a Structured Web of Linked Data as follows:
The Semantic Data Web is an evolution of the current Web (an Information Space) that adds structured data payloads (RDF) to current, less data oriented, structured payloads (HTML, XHTML, XML, and others).
The Semantic Data Web is increasingly seen as an inevitability because it's rapidly reaching the point of critical mass (i.e. network effect kick-in). As a result, Data Web emphasis is moving away from: "What is the Semantic Data Web?" To: "How will Semantic Data Web make our globally interconnected village an even better place?", relative to the contributions accrued from the Web thus far. Remember, the initial "Document Web" (Web 1.0) bootstrapped because of the benefits it delivered to blurb-style content publishing (remember the term electronic brochure-ware?). Likewise, in the case of the "Services Web" (Web 2.0), the bootstrap occurred because it delivered platform independence to Web Application Developers - enabling them to expose application logic behind Web Services. It is my expectation that the Data Integration prowess of the Data Web will create a value exchange realm for data architects and other practitioners from the database and data access realms.
A vital component of the new Virtuoso release is the finalization of our SQL to RDF mapping functionality -- enabling the declarative mapping of SQL Data to RDF. Additional technical insight covering other new features (delivered and pending) is provided by Orri Erling, as part of a series of post-Banff posts.
A majority of the world's data (especially in the enterprise realm) resides in SQL Databases. In addition, Open Access to the data residing in said databases remains the biggest challenge to enterprises for the following reasons:
Enterprises have known from the beginning of modern corporate times that data access, discovery, and manipulation capabilities are inextricably linked to the "Real-time Enterprise" nirvana (hence my use of 0.0 before this becomes 3.0).
In my experience, as someone whose operated in the data access and data integration realms since the late '80s, I've painfully observed enterprises pursue, but unsuccessfully attain, full control over enterprise data (the prized asset of any organization) such that data-, information-, knowledge-workers are just a click away from commencing coherent platform and database independent data drill-downs and/or discovery that transcend intranet, internet, and extranet boundaries -- serendipitous interaction with relevant data, without compromise!
Okay, situation analysis done, we move on..
At our most recent (12th June) monthly Semantic Web Gathering, I unveiled to TimBL and a host of other attendees a simple, but powerful, demonstration of how Linked Data, as an aspect of the Semantic Data Web, can be applied to enterprise data integration challenges.
The vision of data, information, or knowledge at your fingertips is nigh! Thanks to the infrastructure provided by the Semantic Data Web (URIs, RDF Data Model, variety of RDF Serialization Formats[1][2][3], and Shared Data Dictionaries / Schemas / Ontologies [1][2][3][4][5]) it's now possible to Virtualize enterprise data from the Physical Storage Level, through the Logical Data Management Levels (Relational), up to a Concrete Conceptual Model (Graph) without operating system, development environment or framework, or database engine lock-in.
We produce a shared ontology for the CRM and Business Reporting Domains. I hope this experiment clarifies how this is quite achievable by converting XML Schemas to RDF Data Dictionaries (RDF Schemas or Ontologies). Stay tuned :-)
Also watch TimBL amplify and articulate Linked Data value in a recent interview.
To deliver a mechanism that facilitates the crystallization of this reality is a contribution of boundless magnitude (as we shall all see in due course). Thus, it is easy to understand why even "her majesty", the queen of England, simply had to get in on the act and appoint TimBL to the "British Order of Merit" :-)
Note: All of the demos above now work with IE & Safari (a "remember what Virtuoso is epiphany") by simply putting Virtuoso's DBMS hosted XSLT engine to use :-) This also applies to my earlier collection of demos from the Hello Data Web and other Data Web & Linked Data related demo style posts.
]]>Of course, this also enables me to provide yet another Semantic Data Web demo in the form of additional viewing perspectives for the aforementioned FAQ (just click to see):
Lee also embarked on a similar embellishment effort re. the SPARQL Query Language FAQ thereby enabling me to also offer alternative viewing perspectives along similar lines:
]]>Shelley Powers via her post titled: More Ajax Security and many others.
In anticipation of the obvious concerns of many Javascript based developers, Ondrej Zara (lead developer of the OpenLink Ajax Toolkit) has written a post titled: OAT and JS Hijacking, that explains the security aspects our Javascript Toolkit in relation to this alert
]]>]]>"There is a potential problem with republication of transformed data, in that right away there may be inconsistency with the original source data. Here provenance tracking (probably via named graphs) becomes a must-have. The web data space itself can support very granular separation. Whatever, data integration is a hard problem. But if you have a uniform language for describing resources, at least it can be possible."
Alex James also chimes in with valuable insights in his post: Sampling the global data model, where he concludes:
"Exactly we need to use projected views, or conceptual models. 'See a projected view can be thought of as a conceptual model that has some mapping to a *sampling* of the global data model.
The benefits of introducing this extra layer are many and varied: Simplicity, URI predictability, Domain Specificity and the ability to separate semantics from lower level details like data mapping.
Unfortunately if you look at todayâs ORMs you will quickly notice that they simply map directly from Object Model to Data Model in one step.
This naïve approach provides no place to manage the mapping to a conceptual model that sampling the worldâs data requires.
What we need to solve the problems Stefano sees is to bring together the world of mapping and semantics. And the place they will meet is simply the Conceptual Model."
Data Integration challenges arise because the following facts hold true all of the time (whether we like it or not):
- Data Heterogeneity is a fact of life at the intranet and internet levels
- Data is rarely clean
- Data Integration prowess are ultimately measured by pain alleviation
- A some point human participation is required, but the trick is to move human activity up the value chain
- Glue code size and Data Integration success are inversely related
- Data Integration is best addressed via "M" rather than "C" (if we use the MVC pattern as a guide. "V" is dead on arrival for the scrappers out there)
In 1997 we commenced the Virtuoso Virtual DBMS Project that morphed into the Virtuoso Universal Server; A fusion of DBMS functionality and Middleware functionality in a single product. The goal of this undertaking remains alleviation of the costs associated with Data Integration Challenges by Virtualizing Data at the Logical and Conceptual Layers.
The Logical Data Layer has been concrete for a while (e.g Relational DBMS Engines), what hasn't reached the mainstream is the Concrete Conceptual Model, but this is changing fast courtesy of the activity taking place in the realm of RDF.
RDF provides an Open and Standards compliant vehicle for developing and exploiting Concrete Conceptual Data Models that ultimately move the Human aspect of the "Data Integration alleviation quest" higher up the value chain.
Linking personal posted content across communities: "
With the help of Kingsley, Uldis and I have been looking at how SIOC can be used to link the content that a single person posts to a number of community sites. The picture below shows an example of stuff that Iâve created on Flickr, YouTube, etc. through my various user identities on those sites (these match some SIOC types that we want to add to a separate module). We can also say that each Web 2.0 content item is a user-contributed post, with some attached or embedded content (e.g. a file or maybe just some metadata). This is part of a new discussion on the sioc-dev mailing list, and weâd value your contributions.
Edit: The inner layer is a person (semantically described in FOAF), the next layer is their user accounts (described in FOAF, SIOC) and the outer layer is the posted content - text, files, associated metadata - on community sites (again described using SIOC).
No Tags"(Via John Breslin - Cloudlands.)
The point that John is making about the Data Web and Interlinked Data Spaces exposed via URIs (e.g Personal URIs), crystallizes a number of very important issues about the Data Web that may remain unclear. I am hoping that by digesting the post excerpt above, in conjunction with the items below, aids the pursuit of clarity and comprehension about the all important Data Web (Semantic Web - Layer 1):
Examples of some of these principles in practice:
And of course there is more to come such as Grandma's Semantic Web Browser which is coming from Zitgist LLC (pronounced: Zeitgeist) a joint venture of OpenLink Software and Frederick Giasson.
]]>Rich Internet Applications ultimately enable intelligent processing of self-describing databases originating from data servers as demonstrated by these examples:
XMP and microformats revisited: "
Yesterday I exercised poetic license when I suggested that Adobeâs Extensible metadata platform (XMP) was not only the spiritual cousin of microformats like hCalendar but also, perhaps, more likely to see widespread use in the near term. My poetic license was revoked, though, in a couple of comments:
Mike Linksvayer: How someone as massively clued-in as Jon Udell could be so misled as to describe XMP as a microformat is beyond me.
Danny Ayers: Like Mike I donât really understand Jonâs references to microformats - I first assumed he meant XMP could be replaced with a uF.
Actually, Iâm serious about this. If I step back and ask myself what are the essential qualities of a microformat, itâs a short list:
Mike notes:
XMP is embedded in a binary file, completely opaque to nearly all users; microformats put a premium on (practically require) colocation of metadata with human-visible HTML.
Yes, I understand. And as someone who is composing this blog entry as XHTML, in emacs, using a semantic CSS tag that will enable me to search for quotes by Mike Linksvayer and find the above fragment, Iâm obviously all about metadata coexisting with human-readable HTML. And Iâve been applying this technique since long before I ever heard the term microformats â my own term was originally microcontent.
(Via Jon Udell.)
I believe Jon is acknowledging the fact that the propagation of metadata in "Binary based" Web data sources is no different to the microformats based propagation that is currently underway in full swing across the "Text based" Web data sources realm. He is reiterating the fact that the Web is self-annotating (exponentially) by way of Metadata Embedding. And yes, what he describes is a similar to Microformats in substance and propagation style :-)
Here is what I believe Jon is hoping to see:
My little "Hello Data Web!" meme was about demonstrating a view that Danny has sought for a while: unobtrusive meshing of microformats and RDF via GRDDL and SPARQL binding that simply eliminates the often perceived "RDF Tax". Danny, Jon, myself, and many others have always understood that making the Data Web (Web of RDF Instance Data) more of a Force (Star Wars style) is the key to unravelling the power of the "Web as a Database". Of course, we also tend the describe our nirvana in different ways that sometimes obscures the fundamental commonality of vision that we all share.
Personally, I believe everyone should simply "feel the force" or observe "the bright and dark sides of the force" that is RDF. When this occurs en masse there will be a global epiphany (similar to what happened around the time of the initial unveiling of the Web of Hypertext). Jon's meme brings the often overlooked realm of binary based metadata sources into the general discourse.
JBinary Files as bona fide Data Web URIs (i.e. Metadata Sources) is much closer than you think :-) I should have my "Hello Data Web of Binary Data Sources" unveiled very soon!
OAT: OpenAjax Alliance Compliant Toolkit: "
Ondrej Zara and his team at Openlink Software have created a Openlink Software JS Toolkit, known as OAT. It is a full-blown JS framework, suitable for developing
rich applications with special focus to data access.
OAT works standalone, offers vast number of widgets and has some rarely seen features, such as on-demand library loading (which reduces the total amount of downloaded JS code).
OAT is one of the first JS toolkits which show full OpenAjax Alliance conformance: see the appropriate wiki page and conformance test page.
There is a lot to see with this toolkit:
You can see some of the widgets in a Kitchen sink application
Sample data access applications:
OAT is Open Source and GPLâed over at sourceforge and the team has recently managed to incorporate our OAT data access layer as a
module to dojo datastore.
(Via Ajaxian Blog.)
This is a corrected version of the initial post. Unfortunately, the initial post was inadvertently littered with invalid links :-( Also, since the original post we have released OAT 1.2 that includes integration of our iSPARQL QBE into the OAT Form Designer application.
Re. Data Access, It is important to note that OAT's Ajax Database Connectivity layers supports data binding to the following data source types:
OAT also includes a number of prototype applications that are completely developed using OAT Controls and Libraries:
Note: Pick "Local DSN" from page initialization dialog's drop-down list control when prompted
]]>A new and exciting project in the Semantic Web area: The Music Ontology, by Frederic Giasson (PTSW, TalkDigger).
Its goal is to provide a vocabulary to describe Artists, Releases, Songs and so on in RDF. It is mainly based on the MusicBrainz Metadata Vocabulary, but with new improvements as defining relationships between artists and links to external services. And, most important thing, a lot of triples from the current MusicBrainz database should be available in a few weeks. A mailing-list has been launched for discussions and improvements.
I was waiting for this kind of vocabulary (and data) for some time (as I
never took time to look as MBz database export) especially to easilly find all covers of
a given song. From another point of view, I'll be happy to use it to represent
- and query - various releases of a given record (using the
mo:other_release_of property
), especially for vynil records with
reissues (so what about a mo:reissue
property ?) with
different colors, inner sleeve ...
Well, finally what about converting the FLEX book in RDF to query this huge punk and hardcore database (and use its URIs for want-lists) ?
"(Via Alexandre Passant - Terraces.)
]]>SPARQL (query language for the Semantic Web) basically enables me to query a collection of typed links (predicates/properties/attributes) in my Data Space (ODS based of course) without breaking my existing local bookmarks database or the one I maintain at del.icio.us.
I am also demonstrating how Web 2.0 concepts such as Tagging mesh nicely with the more formal concepts of Topics in the Semantic Web realm. The key to all of this is the ability to generate RDF Data Model Instance Data based on Shared Ontologies such as SIOC (from DERI's SIOC Project) and SKOS (again showing that Ontologies and Folksonomies are complimentary).
This demo also shows that Ajax also works well in the Semantic Web realm (or web dimension of interaction 3.0) especially when you have a toolkit with Data Aware controls (for SQL, RDF, and XML) such as OAT (OpenLink Ajax Toolkit). For instance, we've successfully used this to build a Visual Query Building Tool for SPARQL (alpha) that really takes a lot of the pain out of constructing SPARQL Queries (there is much more to come on this front re. handling of DISTINCT, FILTER, ORDER BY etc..).
For now, take a look at the SPARQL Query dump generated by this SIOC & SKOS SPARQL QBE Canvas Screenshot.
You can cut and paste the queries that follow into the Query Builder or use the screenshot to build your variation of this query sample. Alternatively, you can simply click on *This* SPARQL Protocol URL to see the query results in a basic HTML Table. And one last thing, you can grab the SPARQL Query File saved into my ODS-Briefcase (the WebDAV repository aspect of my Data Space).
Note the following SPARQL Protocol Endpoints:
My beautified Version of the SPARQL Generated by QBE (you can cut and paste into "Advanced Query" section of QBE) is presented below:
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX sioc: <http://rdfs.org/sioc/ns#> PREFIX dct: <http://purl.org/dc/elements/1.1/> PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
SELECT distinct ?forum_name, ?owner, ?post, ?title, ?link, ?url, ?tag FROM <http://myopenlink.net/dataspace> WHERE { ?forum a sioc:Forum; sioc:type "bookmark"; sioc:id ?forum_name; sioc:has_member ?owner. ?owner sioc:id "kidehen". ?forum sioc:container_of ?post . ?post dct:title ?title . optional { ?post sioc:link ?link } optional { ?post sioc:links_to ?url } optional { ?post sioc:topic ?topic. ?topic a skos:Concept; skos:prefLabel ?tag}. }
Unmodified dump from the QBE (this will be beautified automatically in due course by the QBE):
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX sioc: <http://rdfs.org/sioc/ns#> PREFIX dct: <http://purl.org/dc/elements/1.1/> PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
SELECT ?var8 ?var9 ?var13 ?var14 ?var24 ?var27 ?var29 ?var54 ?var56 WHERE { graph ?graph { ?var8 rdf:type sioc:Forum . ?var8 sioc:container_of ?var9 . ?var8 sioc:type "bookmark" . ?var8 sioc:id ?var54 . ?var8 sioc:has_member ?var56 . ?var9 rdf:type sioc:Post . OPTIONAL {?var9 dc:title ?var13} . OPTIONAL {?var9 sioc:links_to ?var14} . OPTIONAL {?var9 sioc:link ?var29} . ?var9 sioc:has_creator ?var37 . OPTIONAL {?var9 sioc:topic ?var24} . ?var24 rdf:type skos:Concept . OPTIONAL {?var24 skos:prefLabel ?var27} . ?var56 rdf:type sioc:User . ?var56 sioc:id "kidehen" . } }
Current missing items re. Visual QBE for SPARQL are:
Quick Query Builder Tip: You will need to import the following (using the Import Button in the Ontologies & Schemas side-bar);
Browser Support: The SPARQL QBE is SVG based and currently works fine with the following browsers; Firefox 1.5/2.0, Camino (Cocoa variant of Firefox for Mac OS X), Webkit (Safari pre-release / advanced sibling), Opera 9.x. We are evaluating the use of the Adobe SVG plugin re. IE 6/7 support.
Of course this should be a screencast, but I am the middle of a plethora of things right now :-)
]]>We have lately been busy with RDF scalability. We work with the 8000 university LUBM data set, a little over a billion triples. We can load it in 23h 46m on a box with 8G RAM. With 16G we probably could get it in 16h.
The resulting database is 75G, 74 bytes per triple which is not bad. It will shrink a little more if explicitly compacted by merging adjacent partly filled pages. See Advances in Virtuoso Triple Storage for an in-depth treatment of the subject.
The real question of RDF scalability is finding a way of having more than one CPU on the same index tree without them hitting the prohibitive penalty of waiting for a mutex. The sure solution is partitioning, would probably have to be by range of the whole key. but before we go to so much trouble, well look at dropping a couple of critical sections from index random access. Also some kernel parameters may be adjustable, like a spin count before calling the scheduler when trying to get an occupied mutex. Still we should not waste too much time on platform specifics. Well see.
We just updated the Virtuoso Open Source cut. The latest RDF refinements are not in, so maybe the cut will have to be refreshed shortly.
We are also now applying the relational to RDF mapping discussed in Declarative SQL Schema to RDF Ontology Mapping to the ODS applications.
There is a form of the mapping in the VOS cut on the net but it is not quite ready yet. We must first finish testing it through mapping all the relational schemas of the ODS apps before we can really recommend it. This is another reason for a VOS update in the near future.
We will be looking at the query side of LUBM after the ISWC 2006 conference. So far, we find queries compile OK for many SIOC use cases with the cost model that there is now. A more systematic review of the cost model for SPARQL will come when we get to the queries.
We put some ideas about inferencing in the Advances in Triple Storage paper. The question is whether we should forward chain such things as class subsumption and subproperties. If we build these into the SQL engine used for running SPARQL, we probably can do these as unions at run time with good performance and better working set due to not storing trivial entailed triples. Some more thought and experimentation needs to go into this.
]]>
A declarative language adapted from SPARQL's graph pattern language (N3/Turtle) for mapping SQL Data to RDF Ontologies. We currently refer to this as a Graph Pattern based RDF VIEW Definition Language.
It provides an effective mechanism for exposing existing SQL Data as virtual RDF Data Sets (Graphs) negating the data duplication associated with generating physical RDF Graphs from SQL Data en route to persistence in a dedicated Triple Store.
Enterprise applications (traditional and web based) and most Web Applications (Web 1.0 and Web 2.0) sit atop relational databases, implying that SQL/RDF model and data integration is an essential element of the burgeoning "Data Web" (Semantic Web - Layer 1) comprehension and adoption process.
In a nutshell, this is a quick route for non disruptive exposure of existing SQL Data to SPARQL supporting RDF Tools and Development Environments.
CREATE GRAPH IRI("http://myopenlink.net/dataspace")
CREATE IRI CLASS odsWeblog:feed_iri "http://myopenlink.net/dataspace/kidehen/weblog/MyFeeds" ( in memb varchar not null, in inst varchar not null)
What is Blogosphere 2.0 anyway?
Blog clusters that incorporate the "Open Data Access" dimension to their usage pattern via content exported as RDF Data Sets or Virtual RDF Data Sets (as demonstrated by the OpenLink Data Spaces SIOC Reference). In either scenario, the RDF rendition of blog content is accessible for to ad-hoc querying via SPARQL (btw - checkout this cool SPARQL FAQ).
The really fascinating thing about the "Blgosophere 2.0" is that the transition from "Blogosphere 1.0" is going to be transparent! The "Open Data Access" will actually do the talking etc..
]]>Anyway, we now have OpenID support in OpenLink Data Spaces (ODS) which coincides nicely with the growing support of OpenID across the web.
The beauty of OpenID support in ODS is that I now have a URL that meshes with my identity (at least in line with what I have chosed to share with the public via the Web). For instance, http://www.openlinksw.com/dataspace/kidehen@openlinksw.com is my OpenID as well as my personal URI (you look closer at this link and you have a map of my Data Space).
To really understand what I am getting at here you should open up My OpenID URL using one of the following:
To be continued....
]]>
For additional clarity re. my comments above, you can also look at the SPARQL & SIOC Usecase samples document for our OpenLink Data Spaces platform. Bottom line, the Semantic Web and SPARQL aren't BORING. In fact, quite the contrary, since they are essential ingredients of a more powerful Web than the one we work with today!
Enjoy the rest of John's post:
]]>Creating connections between discussion clouds with SIOC:
(Extract from our forthcoming BlogTalk paper about browsers for SIOC.)
SIOC provides a unified vocabulary for content and interaction description: a semantic layer that can co-exist with existing discussion platforms. Using SIOC, various linkages are created between the aforementioned concepts, which allow new methods of accessing this linked data, including:
- Virtual Forums. These may be a gathering of posts or threads which are distributed across discussion platforms, for example, where a user has found posts from a number of blogs that can be associated with a particular category of interest, or an agent identifies relevant posts across a certain timeframe.
- Distributed Conversations. Trackbacks are commonly used to link blog posts to previous posts on a related topic. By creating links in both directions, not only across blogs but across all types of internet discussions, conversations can be followed regardless of what point or URI fragment a browser enters at.
- Unified Communities. Apart from creating a web page with a number of relevant links to the blogs or forums or people involved in a particular community, there is no standard way to define what makes up an online community (apart from grouping the people who are members of that community using FOAF or OPML). SIOC allows one to simply define what objects are constituent parts of a community, or to say to what community an object belongs (using sioc:has_part / part_of): users, groups, forums, blogs, etc.
- Shared Topics. Technorati (a search engine for blogs) and BoardTracker (for bulletin boards) have been leveraging the free-text tags that people associate with their posts for some time now. SIOC allows the definition of such tags (using the subject property), but also enables hierarchial or non-hierarchial topic definition of posts using sioc:topic when a topic is ambiguous or more information on a topic is required. Combining with other Semantic Web vocabularies, tags and topics can be further described using the SKOS organisation system.
- One Person, Many User Accounts. SIOC also aims to help the issue of multiple identities by allowing users to define that they hold other accounts or that their accounts belong to a particular personal identity (via foaf:holdsOnlineAccount or sioc:account_of). Therefore, all the posts or comments made by a particular person using their various associated user accounts across platforms could be identified.
Continuing from our recent Podcast conversation, Jon Udell sheds further insight into the essence of our conversation via a âStrategic Developerâ column article titled: Accessing the web of databases.
Below, I present an initial dump of a DataSpace FAQ below that hopefully sheds light on the DataSpace vision espoused during my podcast conversation with Jon.
What is a DataSpace?
A moniker for Web-accessible atomic containers that manage and expose Data, Information, Services, Processes, and Knowledge.
What would you typically find in a Data Space? Examples include:
How do Data Spaces and Databases differ?
Data Spaces are fundamentally problem-domain-specific database applications. They offer functionality that you would instinctively expect of a database (e.g. AICD data management) with the additonal benefit of being data model and query language agnostic. Data Spaces are for the most part DBMS Engine and Data Access Middleware hybrids in the sense that ownership and control of data is inherently loosely-coupled.
How do Data Spaces and Content Management Systems differ?
Data Spaces are inherently more flexible, they support multiple data models and data representation formats. Content management systems do not possess the same degree of data model and data representation dexterity.
How do Data Spaces and Knowledgebases differ?
A Data Space cannot dictate the perception of its content. For instance, what I may consider as knowledge relative to my Data Space may not be the case to a remote client that interacts with it from a distance, Thus, defining my Data Space as Knowledgebase, purely, introduces constraints that reduce its broader effectiveness to third party clients (applications, services, users etc..). A Knowledgebase is based on a Graph Data Model resulting in significant impedance for clients that are built around alternative models. To reiterate, Data Spaces support multiple data models.
What Architectural Components make up a Data Space?
Where can I see a DataSpace along the lines described, in action?
Just look at my blog, and take the journey as follows:
What about other Data Spaces?
There are several and I will attempt to categorize along the lines of query method available:
Type 1 (Free Text Search over HTTP):
Google, MSN, Yahoo!, Amazon, eBay, and most Web 2.0 plays .
Type 2 (Free Text Search and XQuery/XPath over HTTP)
A few blogs and Wikis (Jon Udell's and a few others)
What About Data Space aware tools?
]]>
OAT offers a broad Javascript-based, browser-independent widget set
for building data source independent rich internet applications that are usable across a broad range of Ajax-capable web browsers.
OAT's support binding to the following data sources via its Ajax Database Connectivity Layer:
SQL Data via XML for Analysis (XMLA)
Web Data via SPARQL, GData, and OpenSearch Query Services
Web Services specific Data via service specific binding to SOAP and REST style web services
The toolkit includes a collection of powerful rich internet application prototypes include: SQL Query By Example, Visual Database Modeling, and Data bound Web Form Designer.
Project homepage on sourceforge.net:
http://sourceforge.net/projects/oat
Source Code:
http://sourceforge.net/projects/oat/files
Live demonstration:
http://www.openlinksw.com/oat/
]]>I shopped for everything except food on eBay. When working with foreign-language documents, I used translations from Babel Fish. (This worked only so well. After a Babel Fish round-trip through Italian, the preceding sentence reads, 'That one has only worked therefore well.') Why use up space storing files on my own hard drive when, thanks to certain free utilities, I can store them on Gmail's servers? I saved, sorted, and browsed photos I uploaded to Flickr. I used Skype for my phone calls, decided on books using Amazon's recommendations rather than 'expert' reviews, killed time with videos at YouTube, and listened to music through customizable sites like Pandora and Musicmatch. I kept my schedule on Google Calendar, my to-do list on Voo2do, and my outlines on iOutliner. I voyeured my neighborhood's home values via Zillow. I even used an online service for each stage of the production of this article, culminating in my typing right now in Writely rather than Word. (Being only so confident that Writely wouldn't somehow lose my work -- or as Babel Fish might put it, 'only confident therefore' -- I backed it up into Gmail files.Interesting article, Tim O'Reilly's response is here"
(Via Valentin Zacharias (Student).)
Tim O'Reilly's response provides the following hierarchy for Web 2.0 based on The what he calls: "Web 2.0-ness":
level 3: The application could ONLY exist on the net, and draws its essential power from the network and the connections it makes possible between people or applications. These are applications that harness network effects to get better the more people use them. EBay, craigslist, Wikipedia, del.icio.us, Skype, (and yes, Dodgeball) meet this test. They are fundamentally driven by shared online activity. The web itself has this character, which Google and other search engines have then leveraged. (You can search on the desktop, but without link activity, many of the techniques that make web search work so well are not available to you.) Web crawling is one of the fundamental Web 2.0 activities, and search applications like Adsense for Content also clearly have Web 2.0 at their heart. I had a conversation with Eric Schmidt, the CEO of Google, the other day, and he summed up his philosophy and strategy as "Don't fight the internet." In the hierarchy of web 2.0 applications, the highest level is to embrace the network, to understand what creates network effects, and then to harness them in everything you do.
Level 2: The application could exist offline, but it is uniquely advantaged by being online. Flickr is a great example. You can have a local photo management application (like iPhoto) but the application gains remarkable power by leveraging an online community. In fact, the shared photo database, the online community, and the artifacts it creates (like the tag database) is central to what distinguishes Flickr from its offline counterparts. And its fuller embrace of the internet (for example, that the default state of uploaded photos is "public") is what distinguishes it from its online predecessors.
Level 1: The application can and does exist successfully offline, but it gains additional features by being online. Writely is a great example. If you want to do collaborative editing, its online component is terrific, but if you want to write alone, as Fallows did, it gives you little benefit (other than availability from computers other than your own.)
Level 0: The application has primarily taken hold online, but it would work just as well offline if you had all the data in a local cache. MapQuest, Yahoo! Local, and Google Maps are all in this category (but mashups like housingmaps.com are at Level 3.) To the extent that online mapping applications harness user contributions, they jump to Level 2.
So, in a sense we have near conclusive confirmation that Web 2.0 is simply about APIs (typically service specific Data Silos or Walled-gardens) with little concern, understanding, or interest in truly open data access across the burgeoning "Web of Databases". Or the Web of "Databases and Programs" that I prefer to describe as "Data Spaces"
Thus, we can truly begin to conclude that Web 3.0 (Data Web) is the addition of Flexible and Open Data Access to Web 2.0; where the Open Data Access is achieved by leveraging Semantic Web deliverables such as the RDF Data Model and the SPARQL Query Language :-)
]]>
In an initial response to these developmentsOrri Erling, Virtuoso's Program Manager, shares valuable insights from past re. Object-Relational technology developments and deliverables challenges. As Orri notes, the Virtuoso team suspended ORM and ORDBMS work at the onset of the Kubl-Virtuoso transition due to the lack of standardized client-side functionality exposure points.
My hope is that Microsoft's efforts trigger community wide activity that result in a collection of interfaces that make scenarios such as generating .NET based Semantic Web Objects (where the S in an S-P->O RDF-Triple becomes a bona fide .NET class instance generated from OWL).
To be continued since the interface specifics re. ADO.NET 3.0 remain in flux...
]]>Note to Tim:
Is the RDF.net domain deal still on? I know it's past 1st Jan 2006, but do bear in mind that the critical issue of a broadly supported RDF Query Language only took significant shape approximately 13 months ago (in the form of SPARQL), and this is all so critical to the challenge you posed in 2003.
RDF.net could become a point of semantic-web-presence through which the benefits of SPARQL compliant Triple|Quad Stores, Shared Ontologies, and SPARQL Protocol are unveiled in their well intended glory :-).
]]>Standards as social contracts: "Looking at Dave Winer's efforts in evangelizing OPML, I try to draw some rough lines into what makes a de-facto standard. De Facto standards are made and seldom happen on their own. In this entry, I look back at the history of HTML, RSS, the open source movement and try to draw some lines as to what makes a standard.
"(Via Tristan Louis.)
I posted a comment to the Tristan Louis' post along the following lines:
Analysis is spot on re. the link between de facto standardization and bootstrapping. Likewise, the clear linkage between boostrapping and connected communities (a variation of the social networking paradigm).
Dave built a community around a XML content syndication and subscription usecase demo that we know today as the blogosphere. Superficially, one may conclude that Semantic Web vision has suffered to date from a lack a similar bootstrap effort. Whereas in reality, we are dealing with "time and context" issues that are critical to the base understanding upon which a "Dave Winer" style bootstrap for the Semantic Web would occur.
Personally, I see the emergence of Web 2.0 (esp. the mashups phenomenon) as the "time and context" seeds from which the Semantic Web bootstrap will sprout. I see shared ontologies such as FOAF and SIOC leading the way (they are the RSS 2.0's of the Semantic Web IMHO).
]]>The screencasts covered the following functionality realms:
To bring additional clarity to the screencasts demos and OAT in general, I have saved a number of documents that are the by products of activities in the screenvcasts:
Notes:
You can see a full collection of saved documents at the following locations:
Virtuoso extends its SQL3 implementation with syntax for integrating SPARQL into queries and subqueries.Thus, as part of a SQL SELECT query or subquery, one can write the SPARQL keyword and a SPARQL query as part of query text processed by Virtuoso's SQL Query Processor.
Using Virtuoso's Command line or the Web Based ISQL utility type in the following (note: "SQL>" is the command line prompt for the native ISQL utility):
SQL> sparql select distinct ?p where { graph ?g { ?s ?p ?o } };
Which will return the following:
p varchar ---------- http://example.org/ns#b http://example.org/ns#d http://xmlns.com/foaf/0.1/name http://xmlns.com/foaf/0.1/mbox ...
SQL> select distinct subseq (p, strchr (p, '#')) as fragment from (sparql select distinct ?p where { graph ?g { ?s ?p ?o } } ) as all_predicates where p like '%#%' ;
fragment varchar ---------- #query #data #name #comment ...
You can pass parameters to a SPARQL query using a Virtuoso-specific syntax extension. '??' or '$?' indicates a positional parameter similar to '?' in standard SQL. '??' can be used in graph patterns or anywhere else where a SPARQL variable is accepted. The value of a parameter should be passed in SQL form, i.e. this should be a number or an untyped string. An IRI ID can not be passed, but an absolute IRI can. Using this notation, a dynamic SQL capable client (ODBC, JDBC, ADO.NET, OLEDB, XMLA, or others) can execute parametrized SPARQL queries using parameter binding concepts that are common place in dynamic SQL. Which implies that existing SQL applications and development environments (PHP, Ruby, Python, Perl, VB, C#, Java, etc.) are capable of issuing SPARQL queries via their existing SQL bound data access channels against RDF Data stored in Virtuoso.
Note: This is the Virtuoso equivalent of a recently published example using Jena (a Java based RDF Triple Store).
Create a Virtuoso Function by execting the following:
SQL> create function param_passing_demo (); { declare stat, msg varchar; declare mdata, rset any; exec ('sparql select ?s where { graph ?g { ?s ?? ?? }}', stat, msg, vector ('http://www.w3.org/2001/sw/DataAccess/tests/data/Sorting/sort-0#int1', 4 ), -- Vector of two parameters 10, -- Max. result-set rows mdata, -- Variable for handling result-set metadata rset -- Variable for handling query result-set ); return rset[0][0]; }Test new "param_passing_demo" function by executing the following:
SQL> select param_passing_demo ();
Which returns:
callret VARCHAR _______________________________________________________________________________http://www.w3.org/2001/sw/DataAccess/tests/data/Sorting/sort-0#four1 Rows. -- 00000 msec.
A SPARQL ASK query can be used as an argument of the SQL EXISTS predicate.
create function sparql_ask_demo () returns varchar { if (exists (sparql ask where { graph ?g { ?s ?p 4}})) return 'YES'; else return 'NO'; };
Test by executing:
SQL> select sparql_ask_demo ();
Which returns:
_________________________ YES]]>
Sometimes, an application will be making a SPARQL query, using the results from a previous query or using some RDF term found through the other Jena APIs.
SQL has prepared statements - they allow an SQL statement to take a number of parameters. The application fills in the parameters and executes the statement.
One way is to resort to doing this in SPARQL by building
a complete, new query string, parsing it and executing it.
But it takes a little care to handle all cases like
quoting special characters; you can at least use some of the
many utilities in ARQ for producing strings such as
FmtUtils.stringForResource
(it's
not in the application API but in the util
package currently).
Queries in ARQ can be built programmatically but it is tedious, especially when the documentation hasn't been written yet.
Another way is to use query variables and bind them to initial values that apply to all query solutions. Consider the query:
PREFIX dc <http://purl.org/dc/elements/1.1/> SELECT ?doc { ?doc dc:title ?title }
It gets documents and their titles.
Executing a query in program might look like:
import com.hp.hpl.jena.query.* ; Model model = ... ;
String queryString = StringUtils.join('\n', new String[]{ 'PREFIX dc <http://purl.org/dc/elements/1.1/>', 'SELECT ?doc { ?doc dc:title ?title }' }) ; Query query = QueryFactory.create(queryString) ; QueryExecution qexec = QueryExecutionFactory.create(query, model) ; try { ResultSet results = qexec.execSelect() ; for ( ; results.hasNext() ; ) { QuerySolution soln = results.nextSolution() ; Literal l = soln.getLiteral('doc') ; } } finally { qexec.close() ; }
Suppose the application knows the title it's interesting in - can it use this to get the document?
The value of ?title
made a parameter to the query
and fixed by an initial binding. All query solutions will
be restricted to patterns matches where ?title
is that RDF term.
QuerySolutionMap initialSettings = new QuerySolutionMap() ; initialSettings.add('title', node) ;
and this is passed to the factory that creates QueryExecution's:
QueryExecution qexec = QueryExecutionFactory.create(query, model, initialSettings) ;
It doesn't matter if the node is a literal, a resource with URI or a blank node. It becomes a fixed value in the query, even a blank node, because it's not part of the SPARQL syntax, it's a fixed part of every solution.
This gives named parameters to queries enabling something like SQL prepared statements except with named parameters not positional ones.
This can make a complex application easier to structure and clearer to read. It's better than bashing strings together, which is error prone, inflexible, and does not lead to clear code.
(Via ARQtick.)
]]>I added the missing piece regarding the "Virtuoso Conductor" (the Web based Admin UI for Virtuoso) to the original post below. I also added a link to our live SPARQL Demo so that anyone interested can start playing around with SPARQL and SPARQL integrated into SQL right away.
Another good thing about this post is the vast amount of valuable links that it contains. To really appreciate this point simply visit my Linkblog (excuse the current layout :-) - a Tab if you come in via the front door of this Data Space (what I used to call My Weblog Home Page).
]]>"Free" Databases: Express vs. Open-Source RDBMSs: "Open-source relational database management systems (RDBMSs) are gaining IT mindshare at a rapid pace. As an example, BusinessWeek's February 6, 2006 ' Taking On the Database Giants ' article asks 'Can open-source upstarts compete with Oracle, IBM, and Microsoft?' and then provides the answer: 'It's an uphill battle, but customers are starting to look at the alternatives.'
There's no shortage of open-source alternatives to look at. The BusinessWeek article concentrates on MySQL, which BW says 'is trying to be the Ikea of the database world: cheap, needs some assembly, but has a sleek, modern design and does the job.' The article also discusses Postgre[SQL] and Ingres, as well as EnterpriseDB, an Oracle clone created from PostgreSQL code*. Sun includes PostgreSQL with Solaris 10 and, as of April 6, 2006, with Solaris Express.**
*Frank Batten, Jr., the investor who originally funded Red Hat, invested a reported $16 million into Great Bridge with the hope of making a business out of providing paid support to PostgreSQL users. Great Bridge stayed in business only 18 months , having missed an opportunity to sell the business to Red Hat and finding that selling $50,000-per-year support packages for an open-source database wasn't easy. As Batten concluded, 'We could not get customers to pay us big dollars for support contracts.' Perhaps EnterpriseDB will be more successful with a choice of $5,000, $3,000, or $1,000 annual support subscriptions .
**Interestingly, Oracle announced in November 2005 that Solaris 10 is 'its preferred development and deployment platform for most x64 architectures, including x64 (x86, 64-bit) AMD Opteron and Intel Xeon processor-based systems and Sun's UltraSPARC(R)-based systems.'
There is a surfeit of reviews of current MySQL, PostgreSQL andâto a lesser extentâIngres implementations. These three open-source RDBMSs come with their own or third-party management tools. These systems compete against free versions of commercial (proprietary) databases: SQL Server 2005 Express Edition (and its MSDE 2000 and 1.0 predecessors), Oracle Database 10g Express Edition, IBM DB2 Express-C, and Sybase ASE Express Edition for Linux where database size and processor count limitations aren't important. Click here for a summary of recent InfoWorld reviews of the full versions of these four databases plus MySQL, which should be valid for Express editions also. The FTPOnline Special Report article, 'Microsoft SQL Server Turns 17,' that contains the preceding table is here (requires registration.)
SQL Server 2005 Express Edition SP-1 Advanced Features
SQL Server 2005 Express Edition with Advanced Features enhances SQL Server 2005 Express Edition (SQL Express or SSX) dramatically, so it deserves special treatment here. SQL Express gains full text indexing and now supports SQL Server Reporting Services (SSRS) on the local SSX instance. The SP-1 with Advanced Features setup package, which Microsoft released on April 18, 2006, installs the release version of SQL Server Management Studio Express (SSMSE) and the full version of Business Intelligence Development Studio (BIDS) for designing and editing SSRS reports. My 'Install SP-1 for SQL Server 2005 and Express' article for FTPOnline's SQL Server Special Report provides detailed, illustrated installation instructions for and related information about the release version of SP-1. SP-1 makes SSX the most capable of all currently available Express editions of commercial RDBMSs for Windows.
OpenLink Software's Virtuoso Open-Source Edition
OpenLink Software announced an open-source version of it's Virtuoso Universal Server commercial DBMS on April 11, 2006. On the initial date of this post, May 2, 2006, Virtuoso Open-Source Edition (VOS) was virtually under the radar as an open-source product. According to this press release, the new edition includes:VOS only lacks the virtual server and replication features that are offered by the commercial edition. VOS includes a Web-based administration tool called the "Virtuoso Conductor" According to Kingsley Idehen's Weblog, 'The Virtuoso build scripts have been successfully tested on Mac OS X (Universal Binary Target), Linux, FreeBSD, and Solaris (AIX, HP-UX, and True64 UNIX will follow soon). A Windows Visual Studio project file is also in the works (ETA some time this week).'
- SPARQL compliant RDF Triple Store
- SQL-200n Object-Relational Database Engine (SQL, XML, and Free Text)
- Integrated BPEL Server and Enterprise Service Bus
- WebDAV and Native File Server
- Web Application Server that supports PHP, Perl, Python, ASP.NET, JSP, etc.
- Runtime Hosting for Microsoft .NET, Mono, and Java
InfoWorld's Jon Udell has tracked Virtuoso's progress since 2002, with an additional article in 2003 and a one-hour podcast with Kingsley Idehen on April 26, 2006. A major talking point for Virtuoso is its support for Atom 0.3 syndication and publication, Atom 1.0 syndication and (forthcoming) publication, and future support for Google's GData protocol, as mentioned in this Idehen post. Yahoo!'s Jeremy Zawodny points out that the 'fingerprints' of Adam Bosworth, Google's VP of Engineering and the primary force behind the development of Microsoft Access, 'are all over GData.' Click here to display a list of all OakLeaf posts that mention Adam Bosworth.
One application for the GData protocol is querying and updating the Google Base database independently of the Google Web client, as mentioned by Jeremy: 'It's not about building an easier onramp to Google Base. ... Well, it is. But, again, that's the small stuff.' Click here for a list of posts about my experiences with Google Base. Watch for a future OakLeaf post on the subject as the GData APIs gain ground.
Open-Source and Free Embedded Database Contenders
Open-source and free embedded SQL databases are gaining importance as the number and types of mobile devices and OSs proliferate. Embedded databases usually consist of Java classes or Windows DLLs that are designed to minimize file size and memory consumption. Embedded databases avoid the installation hassles, heavy resource usage and maintenance cost associated with client/server RDBMSs that run as an operating system service.
Andrew Hudson's December 2005 'Open Source databases rounded up and rodeoed' review for The Enquirer provides brief descriptions of one commercial and eight open source database purveyors/products: Sleepycat, MySQL, PostgreSQL, Ingres, InnoBase, Firebird, IBM Cloudscape (a.k.a, Derby), Genezzo, and Oracle. Oracle Sleepycat* isn't an SQL Database, Oracle InnoDB* is an OEM database engine that's used by MySQL, and Genezzo is a multi-user, multi-server distributed database engine written in Perl. These special-purpose databases are beyond the scope of this post.
* Oracle purchased Sleepycat Software, Inc. in February 2006 and purchased Innobase OY in October 2005 . The press release states: 'Oracle intends to continue developing the InnoDB technology and expand our commitment to open source software.'
Derby is an open-source release by the Apache Software Foundation of the Cloudscape Java-based database that IBM acquired when it bought Informix in 2001. IBM offers a commercial release of Derby as IBM Cloudscape 10.1. Derby is a Java class library that has a relatively light footprint (2 MB), which make it suitable for client/server synchronization with the IBM DB2 Everyplace Sync Server in mobile applications. The IBM DB2 Everyplace Express Edition isn't open source or free*, so it doesn't qualify for this post. The same is true for the corresponding Sybase SQL Anywhere components.**
* IBM DB2 Everyplace Express Edition with synchronization costs $379 per server (up to two processors) and $79 per user. DB2 Everyplace Database Edition (without DB2 synchronization) is $49 per user. (Prices are based on those when IBM announced version 8 in November 2003.)
** Sybase's iAnywhere subsidiary calls SQL Anywhere 'the industry's leading mobile database.' A Sybase SQL Anywhere Personal DB seat license with synchronization to SQL Anywhere Server is $119; the cost without synchronization wasn't available from the Sybase Web site. Sybase SQL Anywhere and IBM DB2 Everyplace perform similar replication functions.
Sun's Java DB, another commercial version of Derby, comes with the Solaris Enterprise Edition, which bundles Solaris 10, the Java Enterprise System, developer tools, desktop infrastructure and N1 management software. A recent Between the Lines blog entry by ZDNet's David Berlind waxes enthusiastic over the use of Java DB embedded in a browser to provide offline persistence. RedMonk analyst James Governor and eWeek's Lisa Vaas wrote about the use of Java DB as a local data store when Tim Bray announced Sun's Derby derivative and Francois Orsini demonstrated Java DB embedded in the Firefox browser at the ApacheCon 2005 conference.
Firebird is derived from Borland's InterBase 6.0 code, the first commercial relational database management system (RDBMS) to be released as open source. Firebird has excellent support for SQL-92 and comes in three versions: Classic, SuperServer and Embedded for Windows, Linux, Solaris, HP-UX, FreeBSD and MacOS X. The embedded version has a 1.4-MB footprint. Release Candidate 1 for Firebird 2.0 became available on March 30, 2006 and is a major improvement over earlier versions. Borland continues to promote InterBase, now at version 7.5, as a small-footprint, embedded database with commercial Server and Client licenses.
SQLite is a featherweight C library for an embedded database that implements most SQL-92 entry- and transitional-level requirements (some through the JDBC driver) and supports transactions within a tiny 250-KB code footprint. Wrappers support a multitude of languages and operating systems, including Windows CE, SmartPhone, Windows Mobile, and Win32. SQLite's primary SQL-92 limitations are lack of nested transactions, inability to alter a table design once committed (other than with RENAME TABLE and ADD COLUMN operations), and foreign-key constraints. SQLite provides read-only views, triggers, and 256-bit encryption of database files. A downside is the the entire database file is locked when while a transaction is in progress. SQLite uses file access permissions in lieu of GRANT and REVOKE commands. Using SQLite involves no license; its code is entirely in the public domain.The Mozilla Foundation's Unified Storage wiki says this about SQLite: 'SQLite will be the back end for the unified store [for Firefox]. Because it implements a SQL engine, we get querying 'for free', without having to invent our own query language or query execution system. Its code-size footprint is moderate (250k), but it will hopefully simplify much existing code so that the net code-size change should be smaller. It has exceptional performance, and supports concurrent access to the database. Finally, it is released into the public domain, meaning that we will have no licensing issues.'
Vieka Technology, Inc.'s eSQL 2.11 is a port of SQLite to Windows Mobile (Pocket PC and Smartphone) and Win32, and includes development tools for Windows devices and PCs, as well as a .NET native data provider. A conventional ODBC driver also is available. eSQL for Windows (Win32) is free for personal and commercial use; eSQL for Windows Mobile requires a license for commercial (for-profit or business) use.
HSQLDB isn't on most reviewers' radar, which is surprising because it's the default database for OpenOffice.org (OOo) 2.0's Base suite member. HSQLDB 1.8.0.1 is an open-source (BSD license) Java dembedded database engine based on Thomas Mueller's original Hypersonic SQL Project. Using OOo's Base feature requires installing the Java 2.0 Runtime Engine (which is not open-source) or the presence of an alternative open-source engine, such as Kaffe. My prior posts about OOo Base and HSQLDB are here, here and here.
The HSQLDB 1.8.0 documentation on SourceForge states the following regarding SQL-92 and later conformance:
Other less well-known embedded databases designed for or suited to mobile deployment are Mimer SQL Mobile and VistaDB 2.1 . Neither product is open-source and require paid licensing; VistaDB requires a small up-front payment by developers but offers royalty-free distribution.HSQLDB 1.8.0 supports the dialect of SQL defined by SQL standards 92, 99 and 2003. This means where a feature of the standard is supported, e.g. left outer join, the syntax is that specified by the standard text. Many features of SQL92 and 99 up to Advanced Level are supported and here is support for most of SQL 2003 Foundation and several optional features of this standard. However, certain features of the Standards are not supported so no claim is made for full support of any level of the standards.
Java DB, Firebird embedded, SQLite and eSQL 2.11 are contenders for lightweight PC and mobile device database projects that aren't Windows-only.
SQL Server 2005 Everywhere
If you're a Windows developer, SQL Server Mobile is the logical embedded database choice for mobile applications for Pocket PCs and Smartphones. Microsoft's April 19, 2006 press release delivered the news that SQL Server 2005 Mobile Editon (SQL Mobile or SSM) would gain a big brotherâSQL Server 2005 Everywhere Edition.
Currently, the SSM client is licensed (at no charge) to run in production on devices with Windows CE 5.0, Windows Mobile 2003 for Pocket PC or Windows Mobile 5.0, or on PCs with Windows XP Tablet Edition only. SSM also is licensed for development purposes on PCs running Visual Studio 2005. Smart Device replication with SQL Server 2000 SP3 and later databases has been the most common application so far for SSM.
By the end of 2006, Microsoft will license SSE for use on all PCs running any Win32 version or the preceding device OSs. A version of SQL Server Management Studio Express (SSMSE)âupdated to support SSEâis expected to release by the end of the year. These features will qualify SSE as the universal embedded database for Windows client and smart-device applications.
For more details on SSE, read John Galloway's April 11, 2006 blog post and my 'SQL Server 2005 Mobile Goes Everywhere' article for the FTPOnline Special Report on SQL Server."(Via OakLeaf Systems.)
A powerful next generation server product that implements otherwise distinct server functionality within a single server product. Think of Virtuoso as the server software analog of a dual core processor where each core represents a traditional server functionality realm.
The Virtuoso History page tells the whole story.
90% of the aforementioned functionality has been available in Virtuoso since 2000 with the RDF Triple Store being the only 2006 item.
The Virtuoso build scripts have been successfully tested on Mac OS X (Universal Binary Target), Linux, FreeBSD, and Solaris (AIX, HP-UX, and True64 UNIX will follow soon). A Windows Visual Studio project file is also in the works (ETA some time this week).
Simple, there is no value in a product of this magnitude remaining the "best kept secret". That status works well for our competitors, but absolutely works against the legions of new generation developers, systems integrators, and knowledge workers that need to be aware of what is actually achievable today with the right server architecture.
GPL version 2.
Dual licensing.
The Open Source version of Virtuoso includes all of the functionality listed above. While the Virtual Database (distributed heterogeneous join engine) and Replication Engine (across heterogeneous data sources) functionality will only be available in the commercial version.
On SourceForge.
Of course!
Up until this point, the Virtuoso Product Blog has been a covert live demonstration of some aspects of Virtuoso (Content Management). My Personal Blog and the Virtuoso Product Blog are actual Virtuoso instances, and have been so since I started blogging in 2003.
Is There a product Wiki?
Sure! The Virtuoso Product Wiki is also an instance of Virtuoso demonstrating another aspect of the Content Management prowess of Virtuoso.
Yep! Virtuoso Online Documentation is hosted via yet another Virtuoso instance. This particular instance also attempts to demonstrate Free Text search combined with the ability to repurpose well formed content in a myriad of forms (Atom, RSS, RDF, OPML, and OCS).
The Virtuoso Online Tutorial Site has operated as a live demonstration and tutorial portal for a numbers of years. During the same timeframe (circa. 2001) we also assembled a few Screencast style demos (their look feel certainly show their age; updates are in the works).
BTW - We have also updated the Virtuoso FAQ and also released a number of missing Virtuoso White Papers (amongst many long overdue action items).
]]>While the framework of governance continues to evolve there is a widespread belief that along with the growth of the internet, more and more problems such as spam, viruses and 'denial of service' attacks that can cripple large websites shall begin to be felt. It seems reasonable to assume that the number of devices on the network will continue to multiply in new and unforeseen ways. So researchers are starting from the assumption that communications chips and sensors will eventually be embedded in almost everything, from furniture to cereal boxes - 'hundreds of billions of such devices'. While today's internet traffic is generally initiated by humans- as they send e-mails, click on web links, or download music tracks- in future, the vast majority of traffic may be 'machine to machine' communications: things flirting with other things â all ready to be connected wirelessly, and will move around.
The Economist has a related article titled Reinventing the Internet. Asking the question if a can a âclean slateâ redesign of the internet can ever be implemented.
Few solutions float around:
- One is âtrust-modulated transparencyâ. The network's traffic-routing infrastructure shall judge the trustworthiness of packets of data as they pass by and deliver only those deemed trustworthy & dubious packets might be shunted aside for screening. The whole system would be based on a âweb of trustâ, in which traffic flows freely between devices that trust each other, but is closely scrutinized between those that do not.
- Another idea is a new approach to addressing, called âinternet indirection infrastructureâ - It would overlay an additional addressing system on top of the internet-protocol numbers now used to identify devices on the internet. This would make it easier to support mobile devices, and would also allow for âmulticastingâ of data to many devices at once, enabling the efficient distribution of audio, video and software. With Activenets or metanets, devices at the edge of the network could then dynamically reprogram all the routers along the network path between them to use whatever new protocol they wanted.
While the research is still on there some hopes of making some progress on the technical front â but It may well transpire that the greatest impediment to upgrading the internet will turn out to be political disagreements like this , this, over how it should work, rather than the technical difficulty of bringing it about.The OECD hosted a workshop titled The Future of the Internet in Paris on 8 March 2006. Some of the presentations look good and a few of them make a compelling reading.
(Via Sadagopan's weblog on Emerging Technologies,Thoughts, Ideas,Trends and Cyberworld.)
InternetEmerging TechnologiesEmerging Trends]]>WinXP and OSX dual boot in MacBook Pro: "
Finally Iâve succeeded in installing Windows XP in MacBook Pro. Now it can dual boot between Windows XP and MacOS X. Thereâre few issues with windows xp but being able to boot smoothly between these 2 OSes are really amazing. Iâve followed this HOWTO where more and more information is being added every few hours. I think most of the minor problems will be solved soon. If you want to install it for your self or want more information this wiki is the best place to go. Here Iâm posting the photos of major installation sequence and some problems I encountered.
Installation
1. Downloaded winxponmac0.1.zip
Windows XP Pro CD that came with my Samsung Notebook is SP1 but the patch works only with SP2. So this is what I did:
2. Downloaded WinXP SP2 separately.
3. Used the free tool nLite to integrate the WinXP SP2 with the XP Pro CD (SP1) and created the WinXP SP2 CD source.
4. Then followed Step-by-step-instruction
5. Started Windows XP installation.
6. I encountered a problem with the partition listing. I was presented with following options.
According to the guide the correct option should be as following:
If you choose the Partition2 then youâll get follwing error:
7. To solve the above problem I selected the first 'unpartitioned space,' then pressed 'C' to create a new partition. As described in this solution. After this things went smoothly.
8. Finally itâs installed
9. System Properties
10. Device Manager with unrecognized devices.
11. Downloaded the drivers from here. Ethernet works fine. Wireless doesnât work. If I press restart it will shutdown.
12. Browsing my blog.
13. Boot Choice: Mac OSX
14. Boot Choice: Windows XP
Now thereâre few driver issues Iâm quite sure theyâll be solved soon.
" ]]>Anyway, read the post from Doc Searls titled: Saving the Net from the pipeholders
"I've spent much of the last two weeks writing an essay that just went up at Linux Journal: Saving the Net: How to Keep the Carriers from Flushing the Net Down the Tubes. It's probably the longest post I've ever put up on the Web. It's certainly the most important. And not just to me.
I started writing it after a recent surprise visit by David Isenberg to Santa Barbara. He's the one who got me â and, I hope, us â going.
I finished writing it yesterday after David Berlind published threeexcellentpieces, which I highly recommend reading, and acting upon.
For guidance during the rest of this thing (whether they knew it or not), I also want to thank David Weinberger, Dave Winer, Steve Gillmor, Kevin Werbach, Cory Doctorow, Don Marti, Richard M. Stallman, Eric S. Raymond, Susan Crawford, Larry Lessig, John Palfrey, Chris Nolan, Jeff Jarvis, Craig Burton, Andrew Sullivan, Paul Kunz, Dean Landsman, Matt Welch, Sheila Lennon, George Lakoff, Om Malik, Phil Hughes, J.D. Lasica, Virginia Postrel, Chris Anderson, Esther Dyson, Jim Thompson, Micah Sifry, John Perry Barlow, The EFF, the Berkman Center, the Personal Democracy Forum and others I'm overlooking but will fill in later when I have the time.
Although it's kinda huge, Saving the Net wasn't written as a Finished Work, but rather as a conversation starter â a way to change a rock we're pushing uphill to a snowball we're rolling downhill.
Larry Lessig started rolling it at OSCON in 2002, and in various other ways before that, and the whole thing has been too damn sisyphean for too damn long. Time to change that.
There's a thesis involved: that the Net is in danger of becoming what Kevin Werbachcalls'a private toiled garden for the phone companies', but that the real enemy is in how we understand the Net itself. We have choices there, and those choices may mean life or death for the Net as most of us have known it â and taken it for granted â for the last decade or more.
A couple days ago I spoke to a group of about thirty local citizens here in Santa Barbara County, gathered in the County supervisors' conference room to discuss forming a broadband task force. Early on, I asked people what the Net was. The answers were varied, but had one thing in common: it was a place, and not just fiber and copper."
]]>"Ok, my first attempt at a round-up (in response to Philâs observation of Planetary damage). Thanks to the conference thereâs loads more here than thereâs likely to be subsequent weeks, although itâs still only a fairly random sample and some of the links here are to heaps of other resourcesâ¦
Incidentally, if anyoneâs got a list/links for SemWeb-related blogs that arenât on Planet RDF, Iâd be grateful for a pointer. PS. Ok, I forget⦠are there any blogs that arenât on Daveâs list yet..?
Quote of the week:
In the Semantic Web, it is not the Semantic which is new, it is the Web which is new.
- Chris Welty, IBM (lifted from TimBLâs slides)
I just noticed the article from Dan Zambonini âIs Web 2.0 killing the Semantic Web?â. From my perspective the article shows a misconception that people seems to have around the Semantic Web: the Semantic Web effort itself is not provide applications (like the Web 2.0 meme indicates) - it rather provides standards to interlink applications.
Blog post title of the week:
Alsoâ¦a new threat to Semantic Web developers has been discovered: typhoid!, and the key to the Webâs full potential isâ¦Tetris."
]]>Quick Example using my blog:
Digest the rest of Dare's post:
Clone the Google APIs: Kill That Noise: "
Yesterday Dave Winer wrote in a post about cloning the Google API Dave Winer wrote
Let's make the Google API an open standard. Back in 2002, Google took a bold first step to enable open architecture search engines, by creating an API that allowed developers to build applications on top of their search engine. However, there were severe limits on the capacity of these applications. So we got a good demo of what might be, now three years later, it's time for the real thing.and earlier thatIf you didn't get a chance to hear yesterday's podcast, it recommends that Microsoft clone the Google API for search, without the keys, and without the limits. When a developer's application generates a lot of traffic, buy him a plane ticket and dinner, and ask how you both can make some money off their excellent booming application of search. This is something Google can't do, because search is their cash cow. That's why Microsoft should do it. And so should Yahoo. Also, there's no doubt Google will be competing with Apple soon, so they should be also thinking about ways to devalue Google's advantage.This doesn't seem like a great idea to me for a wide variety of reasons but first, let's start with a history lesson before I tackle this specific issue
A Trip Down Memory Lane
This history lessonused to be inis in a post entitled The Tragedy of the API by Evan Williamsbut seems to be gone now. Anyway, back in the early days of blogging the folks at Pyra [which eventually got bought by Google] created the Blogger API for their service. Since Blogspot/Blogger was a popular service, a the number of applications that used the API quickly grew. At this point Dave Winer decided that since the Blogger API was so popular he should implement it in his weblogging tools but then he decided that he didn't like some aspects of it such as application keys (sound familiar?) and did without them in his version of the API. Dave Winer's version of the Blogger API became the MetaWeblog API. These APIs became de facto standards and a number of other weblogging applications implemented them.After a while, the folks at Pyra decided that their API needed to evolve due to various flaws in its design. As Diego Doval put it in his post a review of blogging APIs, The Blogger API is a joke, and a bad one at that. This lead to the creation of the Blogger API 2.0. At this point a heated debate erupted online where Dave Winer berated the Blogger folks for deviating from an industry standard. The irony of flaming a company for coming up with a v2 of their own API seemed to be lost on many of the people who participated in the debate. Eventually the Blogger API 2.0 went nowhere.
Today the blogging API world is a few de facto standards based on a hacky API created by a startup a few years ago, a number of site specific APIs (LiveJournal API, MovableType API, etc) and a number of inconsistently implemented versions of the Atom API.
On Cloning the Google Search API
To me the most salient point in the hijacking of the Blogger API from Pyra is that it didn't change the popularity of their service or even make Radio Userland (Dave Winer's product) catch up to them in popularity. This is important to note since this is Dave Winer's key argument for Microsoft cloning the Google API.Off the top of my head, here are my top three technical reasons for Microsoft to ignore the calls to clone the Google Search APIs
Difference in Feature Set: The features exposed by the API do not run the entire gamut of features that other search engines may want to expose. Thus even if you implement something that looks a lot like the Google API, you'd have to extend it to add the functionality that it doesn't provide. For example, compare the features provided by the Google API to the features provided by the Yahoo! search API. I can count about half a dozen features in the Yahoo! API that aren't in the Google API.
Difference in Technology Choice: The Google API uses SOAP. This to me is a phenomenally bad technical decision because it raises the bar to performing a basic operation (data retrieval) by using a complex technology. I much prefer Yahoo!'s approach of providing a RESTful API and
MSNWindows Live Search's approach of providing RSS search feeds and a SOAP API for the folks who need such overkill.- Unreasonable Demands: A number of Dave Winer's demands seem contradictory. He asks companies to not require application keys but then advises them to contact application developers who've built high traffic applications about revenue sharing. Exactly how are these applications to be identified without some sort of application ID? As for removing the limits on the services? I guess Dave is ignoring the fact that providing services costs money, which I seem to remember is why he sold weblogs.com to Verisign for a few million dollars. I do agree that some of the limits on existing search APIs aren't terribly useful. The Google API limit of 1000 queries a day seems to guarantee that you won't be able to power a popular application with the service.
Lack of Innovation: Copying Google sucks.
Stop whatever you are doing ...: "
.. and go and read Tom Coates' explanation of his last project with the BBC. After 21 years working in broadcasting Ireckon this is one of the coolest things to happen for a very, very long time.
The ramifications of this will go very deep indeed."
(Spotted Via The Obvious?.)
Yes, the ramifications are deep! Tom Coates' screencast demonstrates an internal variation of an activity that is taking place on many fronts (concurrently) across the NET. I tend to refer to this effort as "Self Annotation"; the very process that will ultimately take us straight to "Semantic Web". It is going to happen much quicker than anticipated because technology is taking the pain out of metadata annotation (e.g. what you do when you tag everything that is ultimately URI accessible). Technology is basically delivering what Jon Udell calls: "reducing the activation threshold".
Using my comments above for context placement, I suggest you take a look at, or re-read Jon Udell's post titled: Many Meanings of Metadata.
Once again, the Web 2.0 brouhaha (in every sense of the word) is a reaction to a critical inflection that ultimately transitions the "Semantic Web" from "Mirage" to "Nirvana". Put differently (with humor in mind solely!), Web 2.0 is what I tend to call a "John the Baptist" paradigm, and we all know what happened to him :-)
Web 2.0 is a conduit to a far more important destination. The tendency to treat Web 2.0 as a destination rather than a conduit has contributed to the recent spate of Bozo bit flipping posts all over the blogosphere (is this an attempt to behead John, metaphorically speaking?). Humor aside, a really important thing about the Web 2.0 situation is that when we make the quantum evolutionary leap (internet time, mind you) to the "Semantic Web" (or whatever groovy name we dig up for it in due course) we will certainly have a plethora of reference points (I mean Web 2.0 URIs) ensuring that we do not revisit the "Missing Link" evolutionary paradox :-)
BTW - You can see some example of my contribution to the ongoing annotation process by looking at:
SIOC
(Semantically Interlinked Online Communities) is an attempt to link online community sites and to use Semantic Web technologies to describe the information community sites have about their structure and contents and to find related information and new connections between posts.
From the spec, main terms:
I think I probably linked to this before, but it’s come on apace. They’ve now got plugins for Drupal and WordPress, and from the look of it, a fair load more…
There’s obviously some intersection here with the Atom/OWL stuff, and for that matter a hAtom. Heh, gonna be fun figuring out the equivalences.
(via Uldis)
"(Via Raw.)
]]>Anyway, Marc's article is a very refreshing read because it provides a really good insight into the general landscape of a rapidly evolving Web alongside genuine appreciation of our broader timeless pursuit of "Openness".
To really help this document provide additional value have scrapped the content of the original post and dumped it below so that we can appreciate the value of the links embedded within the article (note: thanks to Virtuoso I only had to paste the content into my blog, the extraction to my Linkblog and Blog Summary Pages are simply features of my Virtuoso based Blog Engine):
]]>Breaking the Web Wide Open! (complete story)
Even the web giants like AOL, Google, MSN, and Yahoo need to observe these open standards, or they'll risk becoming the "walled gardens" of the new web and be coolio no more.
Editorial Note: Several months ago, AlwaysOn got a personal invitation from Yahoo founder Jerry Yang "to see and give us feedback on our new social media product, y!360." We were happy to oblige and dutifully showed up, joining a conference room full of hard-core bloggers and new, new media types. The geeks gave Yahoo 360 an overwhelming thumbs down, with comments like, "So the only services I can use within this new network are Yahoo services? What if I don't use Yahoo IM?" In essence, the Yahoo team was booed for being "closed web," and we heartily agreed. With Yahoo 360, Yahoo continues building its own "walled garden" to control its 135 million customersÂan accusation also hurled at AOL in the early 1990s, before AOL migrated its private network service onto the web. As the Economist recently noted, "Yahoo, in short, has old media plans for the new-media era."
The irony to our view here is, of course, that today's AO Network is also a "closed web." In the end, Mr. Yang's thoughtful invitation and our ensuing disappointment in his new service led to the assignment of this article. It also confirmed our existing plan to completely revamp the AO Network around open standards. To tie it all together, we recruited the chief architect of our new site, the notorious Marc Canter, to pen this piece. We look forward to our reader feedback.
Breaking the Web Wide Open!
By Marc Canter
For decades, "walled gardens" of proprietary standards and content have been the strategy of dominant players in mainframe computer software, wireless telecommunications services, and the World Wide WebÂit was their successful lock-in strategy of keeping their customers theirs. But like it or not, those walls are tumbling down. Open web standards are being adopted so widely, with such value and impact, that the web giantsÂAmazon, AOL, eBay, Google, Microsoft, and YahooÂare facing the difficult decision of opening up to what they don't control.
The online world is evolving into a new open web (sometimes called the Web 2.0), which is all about being personalized and customized for each user. Not only open source software, but open standards are becoming an essential component.
Many of the web giants have been using open source software for years. Most of them use at least parts of the LAMP (Linux, Apache, MySQL, Perl/Python/PHP) stack, even if they aren't well-known for giving back to the open source community. For these incumbents that grew big on proprietary web services, the methods, practices, and applications of open source software development are difficult to fully adopt. And the next open source movementsÂwhich will be as much about open standards as about codeÂwill be a lot harder for the incumbents to exploit.
While the incumbents use cheap open source software to run their back-ends systems, their business models largely depend on proprietary software and algorithms. But our view a new slew of open software, open protocols, and open standards will confront the incumbents with the classic Innovator's Dilemma. Should they adopt these tools and standards, painfully cannibalizing their existing revenue for a new unproven concept, or should they stick with their currently lucrative model with the risk that eventually a bunch of upstarts eat their lunch?
Credit should go to several of the web giants who have been making efforts to "open up." Google, Yahoo, eBay, and Amazon all have Open APIs (Application Programming Interfaces) built into their data and systems. Any software developer can access and use them for whatever creative purposes they wish. This means that the API provider becomes an open platform for everyone to use and build on top of. This notion has expanded like wildfire throughout the blogosphere, so nowadays, Open APIs are pretty much required.
Other incumbents also have open strategies. AOL has got the RSS religion, providing a feedreader and RSS search in order to escape the "walled garden of content" stigma. Apple now incorporates podcasts, the "personal radio shows" that are latest rage in audio narrowcasting, into iTunes. Even Microsoft is supporting open standards, for example by endorsing SIP (Session Initiation Protocol) for internet telephony and conferencing over Skype's proprietary format or one of its own devising.
But new open standards and protocols are in use, under construction, or being proposed every day, pushing the envelope of where we are right now. Many of these standards are coming from startup companies and small groups of developers, not from the giants. Together with the Open APIs, those new standards will contribute to a new, open infrastructure. Tens of thousands of developers will use and improve this open infrastructure to create new kinds of web-based applications and services, to offer web users a highly personalized online experience.
A Brief History of Openness
At this point, I have to admit that I am not just a passive observer, full-time journalist or "just some blogger"Âbut an active evangelist and developer of these standards. It's the vision of "open infrastructure" that's driving my company and the reason why I'm writing this article. This article will give you some of the background behind on these standards, and what the evolution of the next generation of open standards will look like.
Starting back in the 1980s, establishing a software standard was a key strategy for any software company. My former company, MacroMind (which became Macromedia), achieved this goal early on with Director. As Director evolved into Flash, the world saw that other companies besides Microsoft, Adobe, and Apple could establish true cross-platform, independent media standards.
Then Tim Berners-Lee and Marc Andreessen came along, and changed the rules of the software business and of entrepreneurialism. No matter how entrenched and "standardized" software was, the rug could still get pulled out from under it. Netscape did it to Microsoft, and then Microsoft did it back to Netscape. The web evolved, and lots of standards evolved with it. The leading open source standards (such as the LAMP stack) became widely used alternatives to proprietary closed-source offerings.
Open standards are more than just technology. Open standards mean sharing, empowering, and community support. Someone floats a new idea (or meme) and the community runs with it â with each person making their own contributions to the standard â evolving it without a moment's hesitation about "giving away their intellectual property."
One good example of this was Dave Sifry, who built the Technorati blog-tracking technology inspired by the Blogging Ecosystem, a weekend project by young hacker Phil Pearson. Dave liked what he saw and he ran with itÂturning Technorati into what it is today.
Dave Winer has contributed enormously to this area of open standards. He defined and personally created several open standards and protocolsÂsuch as RSS, OPML, and XML-RPC. Dave has also helped build the blogosphere through his enthusiasm and passion.
By 2003, hundreds of programmers were working on creating and establishing new standards for almost everything. The best of these new standards have evolved into compelling web services platforms â such as del.icio.us, Webjay, or Flickr. Some have even spun off formal standards â like XSPF (a standard for playlists) or instant messaging standard XMPP (also known as Jabber).
Today's Open APIs are complemented by standardized SchemasÂthe structure of the data itself and its associated meta-data. Take for example a podcasting feed. It consists of: a) the radio show itself, b) information on who is on the show, what the show is about and how long the show is (the meta-data) and also c) API calls to retrieve a show (a single feed item) and play it from a specified server.
The combination of Open APIs, standardized schemas for handling meta-data, and an industry which agrees on these standards are breaking the web wide open right now. So what new open standards should the web incumbentsÂand youÂbe watching? Keep an eye on the following developments:
Identity
Attention
Open Media
Microcontent Publishing
Open Social Networks
Tags
Pinging
Routing
Open Communications
Device Management and Control
1. Identity
Right now, you don't really control your own online identity. At the core of just about every online piece of software is a membership system. Some systems allow you to browse a site anonymouslyÂbut unless you register with the site you can't do things like search for an article, post a comment, buy something, or review it. The problem is that each and every site has its own membership system. So you constantly have to register with new systems, which cannot share dataÂeven you'd want them to. By establishing a "single sign-on" standard, disparate sites can allow users to freely move from site to site, and let them control the movement of their personal profile data, as well as any other data they've created.
With Passport, Microsoft unsuccessfully attempted to force its proprietary standard on the industry. Instead, a world is evolving where most people assume that users want to control their own data, whether that data is their profile, their blog posts and photos, or some collection of their past interactions, purchases, and recommendations. As long as users can control their digital identity, any kind of service or interaction can be layered on top of it.
Identity 2.0 is all about users controlling their own profile data and becoming their own agents. This way the users themselves, rather than other intermediaries, will profit from their ID info. Once developers start offering single sign-on to their users, and users have trusted places to store their dataÂwhich respect the limits and provide access controls over that data, users will be able to access personalized services which will understand and use their personal data.
Identity 2.0 may seem like some geeky, visionary future standard that isn't defined yet, but by putting each user's digital identity at the core of all their online experiences, Identity 2.0 is becoming the cornerstone of the new open web.
The Initiatives:
Right now, Identity 2.0 is under construction through various efforts from Microsoft (the "InfoCard" component built into the Vista operating system and its "Identity Metasystem"), Sxip Identity, Identity Commons, Liberty Alliance, LID (NetMesh's Lightweight ID), and SixApart's OpenID.
More Movers and Shakers:
Identity Commons and Kaliya Hamlin, Sxip Identity and Dick Hardt, the Identity Gang and Doc Searls, Microsoft's Kim Cameron, Craig Burton, Phil Windley, and Brad Fitzpatrick, to name a few.
2. Attention
How many readers know what their online attention is worth? If you don't, Google and Yahoo doÂthey make their living off our attention. They know what we're searching for, happily turn it into a keyword, and sell that keyword to advertisers. They make money off our attention. We don't.
Technorati and friends proposed an attention standard, Attention.xml, designed to "help you keep track of what you've read, what you're spending time on, and what you should be paying attention to." AttentionTrust is an effort by Steve Gillmor and Seth Goldstein to standardize on how captured end-user performance, browsing, and interest data are used.
Blogger Peter Caputa gives a good summary of AttentionTrust:"As we use the web, we reveal lots of information about ourselves by what we pay attention to. Imagine if all of that information could be stored in a nice neat little xml file. And when we travel around the web, we can optionally share it with websites or other people. We can make them pay for it, lease it ... we get to decide who has access to it, how long they have access to it, and what we want in return. And they have to tell us what they are going to do with our Attention data."
So when you give your attention to sites that adhere to the AttentionTrust, your attention rights (you own your attention, you can move your attention, you can pay attention and be paid for it, and you can see how your attention is used) are guaranteed. Attention data is crucial to the future of the open web, and Steve and Seth are making sure that no one entity or oligopoly controls it.
Movers and Shakers:
Steve Gillmor, Seth Goldstein, Dave Sifry and the other Attention.xml folks.
3. Open Media
Proprietary media standardsÂFlash, Windows Media, and QuickTime, to name a few Âhelped liven up the web. But they are proprietary standards that try to keep us locked in, and they weren't created from scratch to handle today's online content. That's why, for many of us, an Open Media standard has been a holy grail. Yahoo's new Media RSS standard brings us one step closer to achieving open media, as do Ogg Vorbis audio codecs, XSPF playlists, or MusicBrainz. And several sites offer digital creators not only a place to store their content, but also to sell it.
Media RSS (being developed by Yahoo with help from the community) extends RSS and combines it with "RSS enclosures" Âadds metadata to any media itemÂto create a comprehensive solution for media "narrowcasters." To gain acceptance for Media RSS, Yahoo knows it has to work with the community. As an active member of this community, I can tell you that we'll create Media RSS equivalents for rdf (an alternative subscription format) and Atom (yet another subscription format), so no one will be able to complain that Yahoo is picking sides in format wars.
When Yahoo announced the purchase of Flickr, Yahoo founder Jerry Yang insinuated that Yahoo is acquiring "open DNA" to turn Yahoo into an open standards player. Yahoo is showing what happens when you take a multi-billion dollar company and make openness one of its core valuesÂso Google, beware, even if Google does have more research fellows and Ph.D.s.
The open media landscape is far and wide, reaching from game machine hacks and mobile phone downloads to PC-driven bookmarklets, players, and editors, and it includes many other standardization efforts. XSPF is an open standard for playlists, and MusicBrainz is an alternative to the proprietary (and originally effectively stolen) database that Gracenote licenses.
Ourmedia.org is a community front-end to Brewster Kahle's Internet Archive. Brewster has promised free bandwidth and free storage forever to any content creators who choose to share their content via the Internet Archive. Ourmedia.org is providing an easy-to-use interface and community to get content in and out of the Internet Archive, giving ourmedia.org users the ability to share their media anywhere they wish, without being locked into a particular service or tool. Ourmedia plans to offer open APIs and an open media registry that interconnects other open media repositories into a DNS-like registry (just like the www domain system), so folks can browse and discover open content across many open media services. Systems like Brightcove and Odeo support the concept of an open registry, and hope to work with digital creators to sell their work to fulfill the financial aspect of the "Long Tail."
More Movers and Shakers:
Creative Commons, the Open Media Network, Jay Dedman, Ryanne Hodson, Michael Verdi, Eli Chapman, Kenyatta Cheese, Doug Kaye, Brad Horowitz, Lucas Gonze, Robert Kaye, Christopher Allen, Brewster Kahle, JD Lasica, and indeed, Marc Canter, among others.
4. Microcontent Publishing
Unstructured content is cheap to create, but hard to search through. Structured content is expensive to create, but easy to search. Microformats resolve the dilemma with simple structures that are cheap to use and easy to search.
The first kind of widely adopted microcontent is blogging. Every post is an encapsulated idea, addressable via a URL called a permalink. You can syndicate or subscribe to this microcontent using RSS or an RSS equivalent, and news or blog aggregators can then display these feeds in a convenient readable fashion. But a blog post is just a block of unstructured textânot a bad thing, but just a first step for microcontent. When it comes tostructured data, such as personal identity profiles, product reviews, or calendar-type event data, RSS was not designed to maintain the integrity of the structures.
Right now, blogging doesn't have the underlying structure necessary for full-fledged microcontent publishing. But that will change. Think of local information services (such as movie listings, event guides, or restaurant reviews) that any college kid can access and use in her weekend programming project to create new services and tools.
Today's blogging tools will evolve into microcontent publishing systems, and will help spread the notion of structured data across the blogosphere. New ways to store, represent and produce microcontent will create new standards, such as Structured Blogging and Microformats. Microformats differ from RSS feeds in that you can't subscribe to them. Instead, Microformats are embedded into webpages and discovered by search engines like Google or Technorati. Microformats are creating common definitions for "What is a review or event? What are the specific fields in the data structure?" They can also specify what we can do with all this information.OPML (Outline Processor Markup Language) is a hierarchical file format for storing microcontent and structured data. It was developed by Dave Winer of RSS and podcast fame.
Events are one popular type of microcontent. OpenEvents is already working to create shared databases of standardized events, which would get used by a new generation of event portalsâsuch as Eventful/EVDB, Upcoming.org, and WhizSpark. The idea of OpenEvents is that event-oriented systems and services can work together to establish shared events databases (and associated APIs) that any developer could then use to create and offer their own new service or application. OpenReviews is still in the conceptual stage, but it would make it possible to provide open alternatives to closed systems like Epinions, and establish a shared database of local and global reviews. Its shared open servers would be filled with all sorts of reviews for anyone to access.
Why is this important? Because I predict that in the future, 10 times more people will be writing reviews than maintaining their own blog. The list of possible microcontent standards goes on: OpenJobpostings, OpenRecipes, and even OpenLists. Microsoft recently revealed that it has been working on an important new kind of microcontent: Listsâso OpenLists will attempt to establish standards for the kind of lists we all use, such as lists of Links, lists of To Do Items, lists of People, Wish Lists, etc.
Movers and Shakers:
Tantek Ãelik and Kevin Marks of Technorati, Danny Ayers, Eric Meyer, Matt Mullenweg, Rohit Khare, Adam Rifkin, Arnaud Leene, Seb Paquet, Alf Eaton, Phil Pearson, Joe Reger, Bob Wyman among others.
5. Open Social Networks
I'll never forget the first time I met Jonathan Abrams, the founder of Friendster. He was arrogant and brash and he claimed he "owned"Â all his users, and that he was going to monetize them and make a fortune off them. This attitude robbed Friendster of its momentum, letting MySpace, Facebook, and other social networks take Friendster's place.
Jonathan's notion of social networks as a way to control users is typical of the Web 1.0 business model and its attitude towards users in general. Social networks have become one of the battlegrounds between old and new ways of thinking. Open standards for Social Networking will define those sides very clearly. Since meeting Jonathan, I have been working towards finding and establishing open standards for social networks. Instead of closed, centralized social networks with 10 million people in them, the goal is making it possible to have 10 million social networks that each have 10 people in them.
FOAF (which stands for Friend Of A Friend, and describes people and relationships in a way that computers can parse) is a schema to represent not only your personal profile's meta-data, but your social network as well. Thousands of researchers use the FOAF schema in their "Semantic Web" projects to connect people in all sorts of new ways. XFN is a microformat standard for representing your social network, while vCard (long familiar to users of contact manager programs like Outlook) is a microformat that contains your profile information. Microformats are baked into any xHTML webpage, which means thatany blog, social network page, or any webpage in general can "contain" your social network in itÂand be used byany compatible tool, service or application.
PeopleAggregator is an earlier project now being integrated into open content management framework Drupal. The PeopleAggregator APIs will make it possible to establish relationships, send messages, create or join groups, and post between different social networks. (Sneak preview: this technology will be available in the upcoming GoingOn Network.)
All of these open social networking standards mean that inter-connected social networks will form a mesh that will parallel the blogosphere. This vibrant, distributed, decentralized world will be driven by open standards: personalized online experiences are what the new open web will be all aboutÂand what could be more personalized than people's networks?
Movers and Shakers:
Eric Sigler, Joel De Gan, Chris Schmidt, Julian Bond, Paul Martino, Mary Hodder, Drummond Reed, Dan Brickley, Randy Farmer, and Kaliya Hamlin, to name a few.
6. Tags
Nowadays, no self-respecting tool or service can ship without tags. Tags are keywords or phrases attached to photos, blog posts, URLs, or even video clips. These user- and creator-generated tags are an open alternative to what used to be the domain of librarians and information scientists: categorizing information and content using taxonomies. Tags are instead creating "folksonomies."
The recently proposed OpenTags concept would be an open, community-owned version of the popular Technorati Tags service. It would aggregate the usage of tags across a wide range of services, sites, and content tools. In addition to Technorati's current tag features, OpenTags would let groups of people share their tags in "TagClouds." Open tagging is likely to include some of the open identity features discussed above, to create a tag system that is resilient to spam, and yet trustable across sites all over the web.
OpenTags owes a debt to earlier versions of shared tagging systems, which include Topic Exchange and something called the k-collectorÂa knowledge management tag aggregatorÂfrom Italian company eVectors.
Movers & Shakers:
Phil Pearson, Matt Mower , Paolo Valdemarin, and Mary Hodder and Drummond Reed again, among others.
7. Pinging
Websites used to be mostly static. Search engines that crawled (or "spidered") them every so often did a good enough job to show reasonably current versions of your cousin's homepage or even Time magazine's weekly headlines. But when blogging took off, it became hard for search engines to keep up. (Google has only just managed to offer blog-search functionality, despite buying Blogger back in early 2003.)
To know what was new in the blogosphere, users couldn't depend on services that spidered webpages once in a while. The solution: a way for blogs themselves to automatically notify blog-tracking sites that they'd been updated. Weblogs.com was the first blog "ping service": it displayed the name of a blog whenever that blog was updated. Pinging sites helped the blogosphere grow, and more tools, services, and portals started using pinging in new and different ways. Dozens of pinging services and sitesÂmost of which can't talk to each otherÂsprang up.
Matt Mullenweg (the creator of open source blogging software WordPress) decided that a one-stop service for pinging was needed. He created Ping-o-MaticÂwhich aggregates ping services and simplifies the pinging process for bloggers and tool developers. With Ping-o-Matic, any developer can alert all of the industry's blogging tools and tracking sites at once. This new kind of open standard, with shared infrastructure, is a critical to the scalability of Web 2.0 services.
As Matt said:There are a number of services designed specifically for tracking and connecting blogs. However it would be expensive for all the services to crawl all the blogs in the world all the time. By sending a small ping to each service you let them know you've updated so they can come check you out. They get the freshest data possible, you don't get a thousand robots spidering your site all the time. Everybody wins.
Movers and Shakers:
Matt Mullenweg, Jim Winstead, Dave Winer
8. Routing
Bloggers used to have to manually enter the links and content snippets of blog posts or news items they wanted to blog. Today, some RSS aggregators can send a specified post directly into an associated blogging tool: as bloggers browse through the feeds they subscribe to, they can easily specify and send any post they wish to "reblog" from their news aggregator or feed reader into their blogging tool. (This is usually referred to as "BlogThis.") As structured blogging comes into its own (see the section on Microcontent Publishing), it will be increasingly important to maintain the structural integrity of these pieces of microcontent when reblogging them.
Promising standard RedirectThis will combine a "BlogThis"-like capability while maintaining the integrity of the microcontent. RedirectThis will let bloggers and content developers attach a simple "PostThis" button to their posts. Clicking on that button will send that post to the reader/blogger's favorite blogging tool. This favorite tool is specified at the RedirectThis web service, where users register their blogging tool of choice. RedirectThis also helps maintain the integrity and structure of microcontentÂthen it's just up to the user to prefer a blogging tool that also attains that lofty goal of microcontent integrity.
OutputThis is another nascent web services standard, to let bloggers specify what "destinations" they'd like to have as options in their blogging tool. As new destinations are added to the service, more checkboxes would get added to their blogging toolÂallowing them to route their published microcontent to additional destinations.
Movers and Shakers:
Michael Migurski, Lucas Gonze
9. Open Communications
Likely, you've experienced the joys of finding friends on AIM or Yahoo Messenger, or the convenience of Skyping with someone overseas. Not that you're about to throw away your mobile phone or BlackBerry, but for many, also having access to Instant Messaging (IM) and Voice over IP (VoIP) is crucial.
IM and VoIP are mainstream technologies that already enjoy the benefits of open standards. Entire industries are bornÂright this secondÂbased around these open standards. Jabber has been an open IM technology for yearsÂin fact, as XMPP, it was officially dubbed a standard by the IETF. Although becoming an official IETF standard is usually the kiss of death, Jabber looks like it'll be around for a while, as entire generations of collaborative, work-group applications and services have been built on top of its messaging protocol. For VoIP, Skype is clearly the leading standard todayÂthough one could argue just how "open" it is (and defenders of the IETF's SIP standard often do). But it is free and user-friendly, so there won't be much argument from users about it being insufficiently open. Yet there may be a cloud on Skype's horizon: web behemoth Google recently released a beta of Google Talk, an IM client committed to open standards. It currently supports XMPP, and will support SIP for VoIP calls.
Movers and Shakers:
Jeremie Miller, Henning Schulzrinne, Jon Peterson, Jeff Pulver
10. Device Management and Control
To access online content, we're using more and more devices. BlackBerrys, iPods, Treos, you name it. As the web evolves, more and more different devices will have to communicate with each other to give us the content we want when and where we want it. No-one wants to be dependent on one vendor anymoreÂlike, say, SonyÂfor their laptop, phone, MP3 player, PDA, and digital camera, so that it all works together. We need fully interoperable devices, and the standards to make that work. And to fully make use of how content is moving online content and innovative web services, those standards need to be open.
MIDI (musical instrument digital interface), one of the very first open standards in music, connected disparate vendors' instruments, post-production equipment, and recording devices. But MIDI is limited, and MIDI II has been very slow to arrive. Now a new standard for controlling musical devices has emerged: OSC (Open SoundControl). This protocol is optimized for modern networking technology and inter-connects music, video and controller devices with "other multimedia devices." OSC is used by a wide range of developers, and is being taken up in the mainstream MIDI marketplace.
Another open-standards-based device management technology is ZigBee, for building wireless intelligence and network monitoring into all kinds of devices. ZigBee is supported by many networking, consumer electronics, and mobile device companies.
   · · · · · ·  Â
The Change to Openness
The rise of open source software and its "architecture of participation" are completely shaking up the old proprietary-web-services-and-standards approach. Sun MicrosystemsÂwhose proprietary Java standard helped define the Web 1.0Âis opening its Solaris OS and has even announced the apparent paradox of an open-source Digital Rights Management system.
Today's incumbents will have to adapt to the new openness of the Web 2.0. If they stick to their proprietary standards, code, and content, they'll become the new walled gardensÂplaces users visit briefly to retrieve data and content from enclosed data silos, but not where users "live." The incumbents' revenue models will have to change. Instead of "owning" their users, users will know they own themselves, and will expect a return on their valuable identity and attention. Instead of being locked into incompatible media formats, users will expect easy access to digital content across many platforms.
Yesterday's web giants and tomorrow's users will need to find a mutually beneficial new balanceÂbetween open and proprietary, developer and user, hierarchical and horizontal, owned and shared, and compatible and closed.
Marc Canter is an active evangelist and developer of open standards. Early in his career, Marc founded MacroMind, which became Macromedia. These days, he is CEO of Broadband Mechanics, a founding member of the Identity Gang and of ourmedia.org. Broadband Mechanics is currently developing the GoingOn Network (with the AlwaysOn Network), as well as an open platform for social networking called the PeopleAggregator.
A version of the above post appears in the Fall 2005 issue of AlwaysOn's quarterly print blogozine, and ran as a four-part series on the AlwaysOn Network website.(Via Marc's Voice.)
David Cowan is a partner at Bessemer Venture Partners and writes a blog called Who Has Time For This. Heâs on this list partially because he incubated the hottest and most anticipated company on the web right now, Flock.]]>
Tim Draper invested in Skype. Done. He also sits on the board of SocialText, and his fund was in Baidu.
David Hornik is is a General Partner at August Capital and writes a blog that has over 10,000 RSS readers.
Josh Kopelman, through FirstRoundCapital, is quietly filtering through just about every young web 2.0 company, and investing in many of them.
Fred Wilson is a founding partner of Union Square Ventures and writes the extremely popular A VC. If you are new to web 2.0, start with his Blogging 1.0 post.
Jeff Clavier - Jeff is a former VC and still makes the odd angel investment (Feedster, Truveo, and a few others). His new venture allows him to work with pre-funding companies and get them ready for prime time.
Brad Feld - Brad is a managing director at Mobius Venture Capital and writes a must-read web 2.0 blog called Feld Thoughts. Read his posts on Term Sheets if you are in the process of raising capital.
OâReilly AlphaTech Ventures - This is the only non-person on here. OATV just closed a $50 million fund to invest in young companies. Given the incredible access Tim OâReilly has to these companies, OATV could quickly become an important fund in the web 2.0 space.
Pierre Omidyar - Pierre founded ebay and is the Co-founder of Omidyar Network, where heâs invested in a number of interesting companies including EVDB, SocialText and Feedster, and others.
Peter Rip - Peter is a founding partner of Leapfrog Ventures, a $100 million fund. Peter also writes Early Stage VC, another must-read blog. His investments include ojos, an incredible new photo-metadata service that is going to be extremely disruptive (and useful).
Peter Thiel - Peter, the former CEO of paypal, has invested in LinkedIn, Friendster, LinkedIn and other web 2.0 companies. Heâs just created the Founders Fund.
Thomas Ball - Tom is a Venture Partner at Austin Ventures, a fund with $3 billion under management. Heâs their consumer and web 2.0 guy and seems to be spending a lot of time in Silicon Valley and at web 2.0 event.
Dan Grossman - Dan is a principal at Venrock Associates and has recently started a great blog called A Venture Forth (where he wrote a much bookmarked post on Ajax).
Jason Pressman - Jason is a principal at Shasta Ventures, a young $200 million fund that has a deep commitment to and expertise in consumer-focused businesses.
]]>Web 2.0 Conference Trip Report: Mash-ups 2.0 - Where's the Business Model?: "
I attended the panel on business models for mash-ups hosted by Dave McClure,
Jeffrey McManus, Paul Rademacher, and Adam Trachtenberg.A mash up used to mean remixing two songs into something new and cool but now the term has been hijacked by geeks to means mixing two or more web-based data sources and/or services.
Paul Rademacher is the author of the Housing Maps mash-up which he used as a way to find a house using Craig'sList + Google Maps. The data obtained from Craig's List is fetched via screen scraping. Although Craig's List has RSS feeds, they didn't meet his needs. Paul also talked about some of the issues he had with building the site such as the fact that since most browsers block cross-site scripting using XMLHttpRequest then a server needs to be set up to aggregate the data instead of all the code running in the browser. The site has been very popular and has garnered over 900,000 unique visitors based solely on word-of-mouth.
The question was asked as to why he didn't make this a business but instead took a job at Google. He listed a number of very good reasons
- He did not own the data that was powering the application.
- The barrier to entry for such an application was low since there was no unique intellectual property or user interface design to his application
I asked whether he'd gotten any angry letters from the legal department at Craig's List and he said they seem to be tolerating him because he drives traffic to their site and caches a bunch of data on his servers so as not to hit their servers with a lot of traffic.Â
A related mash-up site which scrapes real estate websites called Trulia was then demoed. A member of the audience asked whether Paul thought the complexity of mash-ups using more than two data sources and/or services increased in a linear or exponential fashion. Paul said he felt it increased in a linear fashion. This segued into a demo of SimplyHired with integrates with a number of sites including PayScale, LinkedIn, Job databases, etc.
At this point I asked whether they would have service providers giving their perspective on making money from mash-ups since they are the gating factor because they own the data and/or services mash-ups are built on. The reply was that the eBay & Yahoo folks would give their perspective later.
Then we get a demo of a Google Maps & eBay Motors mash-up. Unlike the Housing Maps mash-up, all the data is queried live instead of cached on the server. eBay has dozens of APis that encourage people to build against their platform and they have an affiliates program so people can make money from building on their API. We also got showed Unwired Buyer which is a site that enables you to bid on eBay using your cell phone and even calls you just before an auction is about to close. Adam Trachtenberg pointed out that since there is a Skype API perhaps some enterprising soul could mash-up eBay & Skype.
Jeffrey McManus of Yahoo! pointed out that you don't even need coding skills to build a Yahoo! Maps mash-up since all it takes is specifying your RSS feed with longitude and latitude elements on each item to have it embedded in the map. I asked why unlike Google Maps and MSN Virtual Earth, Yahoo! Maps doesn't allow users to host the maps on their page nor does there seem to be an avenue for revenue sharing with mash-up authors via syndicated advertising. The response I got was that they polled various developers and there wasn't significant interest in embedding the maps on developer's sites especially when this would require paying for hosting.
We then got showed a number mapping mashups including a mashup of the London bombings which used Google Maps, Flickr & RSS feeds of news (the presenter had the poor taste to point out opportunities to place ads on the site), a mashup from alkemis which mashes Google Maps, A9.com street level photos and traffic cams, and a mash-up from Analygis which integrates census data with Google Maps data.
The following items were then listed as the critical components of mash-ups
 - AJAX (Jeffrey McManus said it isn't key but a few of the guys on the panel felt that at least dynamic UIs are better)
 - APIs
 - Advertising
 - Payment
 - Identity/Acct mgmt
 - Mapping Services
 - Content Hosting
 - Other?On the topic of identity and account management, the problem of how mash-ups handle user passwords came up as a problem. If a website is password protected then user's often have to enter their usernames and passwords into third party sites. An example of this was the fact that PayPal used to store lots of username/password information of eBay users which caused the company some consternation since eBay went through a lot of trouble to protect their sensitive data only to have a lot of it being stored on Paypal servers.
eBay's current solution is similar to that used by Microsoft Passport in that applications are expected to have user's login via the eBay website then the user is redirected to the originating website with a ticket indicating they have been authenticated. I pointed out that although this works fine for websites, it offers no solution for people trying to build desktop applications that are not browser based. The response I got indicated that eBay hasn't solved this problem.
My main comment about this panel is that it didn't meet expectations. I'd expected to hear a discussion about turning mashups [and maybe the web platforms they are built on] into money making businesses. What I got was a show-and-tell of various mapping mashups. Disappointing.
"
just take a look at the oxymoronic Wikipedia 2.0 imbroglio to get my drift. In retrospect, I should have called on Esquire magazine to get the Web 2.0 article going :-) ).Anyway, back to Dare's analysis of Tim's 7 Web 2.0 litmus test items listed below:
And trimmed down to 3 by Dare:
- Services, not packaged software, with cost-effective scalability
- Control over unique, hard-to-recreate data sources that get richer as more people use them
- Trusting users as co-developers
- Harnessing collective intelligence
- Leveraging the long tail through customer self-service
- Software above the level of a single device
- Lightweight user interfaces, development models, AND business models
Well, I would like to summarize this a little further using a few excerpts from my numerous contributions to the Web 2.0 talk page on Wikipedia (albeit mildly revised; see strikeouts etc.):
Exposes Web services that can be accessed on any device or platform by any developer or user. RSS feeds, RESTful APIs and SOAP APIs are all examples of Web services. Harnesses the collective knowledge of its user base to benefit users Leverages the long tail through customer self-service
Web 2.0 is a web ofexecutableservice invocation endpoints (those Web Services URIs) and well-formed content (all of that RSS, Atom, RDF, XHTML, etc. based Web Content out on the NET). Theexecutableservice invocation endpoints and well-formed content are accessible via URIs.Put in even simpler terms, Web 2.0 is an incarnation of the web defined by URIs for invoking Web Services and/or consuming or syndicating well-formed content.
Looks like I've self edited my own definition in the process. :-)
If you don't grok this definition then consider using it as a trigger for taking a closer look at the dynamics that genuinely differentiate Web 1.0 and Web 2.0.
In another Wikipedia "talk page" contribution (regarding "Web 2.0 Business Impact") I attempt to answer the question posed here, which should also shed light on the premise of my definition above:Web 1.0 was about web sites geared towards an interaction with human beings as opposed to computers. In a sense this mirrors the difference between HTML and XML.
A simple example (purchasing a book):
amazon.com provides value to you by enabling you to search and purchase the desired book online via the site http://www.amazon.com.
In the Web 1.0 era the process of searching for your desired book, and then eventually purchasing the book in question, required visible interaction with the site http://www.amazon.com. In today's Web 2.0 based Web the process of discovering a catalog of books, searching for your particular book of interest, and eventually purchasing the book, occurs via Web Services which amazon has chosen to expose via an executable endpoint (the Web point of presence for exposing its Web Services).
Direct interaction via http://www.amazon.com is no longer required. A weblog can quite easily associate keywords, tags, and post categories with items in amazon.com's catalogs. In addition, weblogs can also act as entry points for consuming the amazon.com value proposition (making books available for purchase online), by enabling you to purchase a book directly from the weblog (assuming the blog owner is an amazon associate etc..). Now compare the impact of this kind of value discovery and consumption cycle driven by software to the same process driven by humans interaction with a static or dynamic HTML page (Web 1.0 site).
To surmise, Web 2.0 is a reflection of the potential of XML expressed through the collective impact of Web Services (XML based distributed computing) and Well-formed Content (Blogosphere, Wikisphere, XHTML micro content etc.). The potential simply comes down to the ability to ultimately connect events, triggers, impulses (chatter, conversation, etc.), and data in general via URIs.
Let's never forget that XML is the reason why we have a blogosphere (RSS/Atom/RDF are applications of XML). Likewise, XML is also the reason why we have Web Services (doesn't matter what format).
As I have stated in the past, we must go by Web 2.0 en route what is popularly referred to as the Semantic Web (it will be known by another name by the time we get there; 3.0 or 4.0, who knows or cares?). At the current time, the prerequisite activity of self annotation is in full swing on the current Web, thanks to the inflective effects of Web 2.0.
BTW - Would this URI to all Semantic Web related posts on my blog pass the Web 2.0 litmus test? Likewise, this URI to all Web 2.0 related posts? I wonder :-)
]]>NerdTV has first Macintosh programmer: "
NerdTV has Andy Hertzfield, the first Macintosh programmer....
(Via Scobleizer: Microsoft Geek Blogger.)
Here is the juicy excerpt that covers the issue of "Bill Gates, Microsoft and Taste.." :-) Very funny!
]]>I ran into two work-related problems today that left me feeling like there are some aspects of two very recent (Web 2.0-esque if we wish to join the buzzword orgy of late) architectures (REST/Services and XForms) that are problematic:
XML as a medium for remote communication (evangelized more with WSDL-related architectures than in REST) has over-stated its usefullness in at least one concrete regard, in my estimation. I've had a hard time taking most of the architectural arguments on the pros/cons of SOAP/XML-RPC versus REST seriously because it seems to be nothing more than buzzword warfare. However, I recently came across a concrete, real world example of the pitfalls of implementing certain remote service needs on XML-based communication mediums (such as SOAP/XML-RPC).
If the objects/resources you wish to manipulate at the service endpoints are run of the mill (consider the standard cliche purchase order example(s)) then the benefits of communicating in XML is obvious: portability, machine readability, extensibility, etc.. However consider the scenario (which I face) in which the objects/resources you wish to manipulate are XML documents themselves! This scenario seems to work to the disadvantage of the communication architecture.
Lets say you have a repository at one end (which I do) that has XML documents you wish to manipulate remotely. How do you update the documents? I've discussed this before (see: Base64 encoded XML content from an XForm) so I'll spare the details of the problem. However, I will mention that in retrospect this particular problem further emphasizes the advantage of a MinimalistRemoteProcedureCall (MRPC) approach - MRPC is my alternative acronym for REST :).
Consider the setContent message:
[SOAP:Envelope]
[SOAP:Body]
[foo:setContent]
[path] .. path to document [/path]
[src]... new document as a fragment ...[/src]
[/foo:setContent]
[/SOAP:Body]
[/SOAP:Envelope]
Notice that the location of the resource we wish to update is embedded within the message transmitted (via SOAP), which is transported on top of another communication medium (HTTP) that already has the neccessary semantics for saying the same thing:
Set the content of the resource identified by a path
In the SOAP scenario, the above message is delivered to a single service endpoint (which serves as an external gateway for all SOAP messages) which has to then parse the entire XML message in order to determine the method invoked (setContent in this case) and the parameters passed to it (both of which are only header information on a document that consists mostly of the new document).
However, in the MRPC scenario this service would be invoked simply as an HTTP PUT request sent directly to the XML document we wish to update:
Method: PUT
Protocol: HTTP/1.0
URI: http://remoteHost:port/< .. path to XML document ..>
CONTENT:
... new document in it's entirety ..
Here, there is no need for a service middleman to interpret the service requested (and no need to parse a large XML document that contains another document embedded as a fragment). The HTTP request by itself specifies everything we need and does it using HTTP alone as the communication medium. This is even more advantageous when the endpoint is a repository that has a very well defined URI scheme or general addressing mechanism for it's resources (which 4Suite does, the repository in my case).
Since i didn't have the option of a REST-based service architecture (the preferred solution) I was relegated to having to base64 encode the new XML content and embed it within the XML message submitted to the service endpoint, like so:
[SOAP:Envelope]
[SOAP:Body]
[foo:setContent]
[path] .. path to document [/path]
[src]... base64 encoding of new document's serialization ...[/src]
[/foo:setContent]
[/SOAP:Body]
[/SOAP:Envelope]
Base 64 seemed like the obvious encoding mechanism mostly because it would seem from an interpretation of the XForms specification that due to the data binding restrictions of the Upload Control when bound to instances of type xsd:base64Binary a conforming XForms processor is responsible for having the capability to encode to Base 64 on the fly. Now, this is fine and dandy if the XML content you wish to submit is retrieved from a file on the local file system of the client communicating remotely with the server. However, what if you wish to use an instance (a live DOM) as the source for the update? This seems like a very reasonable requirement given that one of the primary motivation of XForms is to encourage the use of XML instances as the user interface data model (providing a complete solution to the 'M' in the MVC architecture.)
However:
(Via Uche Ogbuji.)
]]>The value of the Internet as a repository of useful information is very low. Carl Shapiro in âInformation Rulesâ suggests that the amount of actually useful information on the Internet would fit within roughly 15,000 books, which is about half the size of an average mall bookstore. To put this in perspective: there are over 5 billion unique, static & publicly accessible web pages on the www. Apparently Only 6% of web sites have educational content (Maureen Henninger, âDonât just surf the net: Effective research strategiesâ. UNSW Press). Even of the educational content only a fraction is of significant informational value.
..As Stanford students, Larry Page and Sergey Brin looked at the same problemâhow to impart meaning to all the content on the Webâand decided to take a different approach. The two developed sophisticated software that relied on other clues to discover the meaning of content, such as which Web sites the information was linked to. And in 1998 they launched Google..
You mean noise ranking. Now, I don't think Larry and Sergey set out to do this, but Google page ranks are ultimately based on the concept of "Google Juice" (aka links). The value quotient of this algorithm is accelerating at internet speed (ironically, but naturally). Human beings are smarter than computers, we just process data (not information!) much slower that's all. Thus, we can conjure up numerous ways to bubble up the google link ranking algorithms in no time (as is the case today).
..What most differentiates Google's approach from Berners-Lee's is that Google doesn't require people to change the way they post content..
The Semantic Web doesn't require anyone to change how they post content either! It just provides a roadmap for intelligent content managment and consumption through innovative products.
..As Sergey Brin told Infoworld's 2002 CTO Forum, "I'd rather make progress by having computers under-stand what humans write, than by forcing -humans to write in ways that computers can understand." In fact, Google has not participated at all in the W3C's formulation of Semantic Web standards, says Eric Miller..
Semantic Content generated by next generation content managers will make more progress, and they certainly won't require humans to write any differently. If anything, humans will find the process quite refreshing as and when participation is required e.g. clicking bookmarklets associated with tagging services such as 'del.icio.us', 'de.lirio.us', or Unalog and others. But this is only the beginning, if I can click on a bookmarklet to post this blog post to a tagging service, then why wouldn't I be able to incorporate the "tag service post" into the same process that saves my blog post (the post is content that ends up in a content management system aka blog server)?
Yet Google's impact on the Web is so dramatic that it probably makes more sense to call the next generation of the Web the "Google Web" rather than the "Semantic Web."
Ah! so you think we really want the noisy "Google Web" as opposed to a federation of distributed Information- and Knowledgbases ala the "Semantic Web"? I don't think so somehow!
Today we are generally excited about "tagging" but fail to see its correlation with the "Semantic Web", somehow? I have said this before, and I will say it again, the "Semantic Web" is going to be self-annotated by humans with the aid of intelligent and unobtrusive annotation technology solutions. These solutions will provide context and purpose by using our our social essence as currency. The annotation effort will be subliminal, there won't be a "Semantic Web Day" parade or anything of the like. It will appear before us all, in all its glory, without any fanfare. Funnily enough, we might not even call it "The Semantic Web", who cares? But it will have the distinct attributes of being very "Quiet" and highly "Valuable"; with no burden on "how we write", but constructive burden on "why we write" as part of the content contribution process (less Google/Yahoo/etc juice chasing for more knowledge assembly and exchange).
We are social creatures at our core. The Internet and Web have collectively reduced the connectivity hurdles that once made social network oriented solutions implausible. The eradication of these hurdles ultimately feeds the very impulses that trigger the critical self-annotation that is the basis of my fundamental belief in the realization of TBL's Semantic Web vision.
Â
]]>While I'm still trying to figure this out, you should read Shelley's original post, Steve Levy, Dave Sifry, and NZ Bear: You are Hurting Us and see whether you think the arguments against blogrolls are as wrong as I think they are.
"..The Technorati Top 100 is too much like Google in that âÂÂnoiseâ becomes equated with âÂÂauthorityâÂÂ. Rather than provide a method to expose new voices, your list becomes nothing more than a way for those on top to further cement their positions. More, it can be easily manipulated with just the release of a piece of software.."
]]>On the surface, Grahamâs piece seems like a nice pat on the back to the Mac platform. But thereâs an implication in his piece that the worldâs most prodigiously talented programmers are only now switching (or switching back) to the Mac, when in fact some of them have been here all along. GUI programming is hard, and for GUI programmers, the Mac has always been, in Brent Simmonsâs words, âThe Showâ.
I.e. the idea that by the mid-â90s the Mac user base had been whittled down to âgraphic designers and grandmasâ is demonstrably false â someone must have been writing the software the designers and grandmas were using, no? â but I donât think itâs worth pressing the point, because I suspect it wasnât really what Graham meant to imply. And the main thrust of his point is true: there is a certain class of hackers â your prototypical Unix nerds â who not only werenât using Macs a decade ago, but whose antipathy toward Macs was downright hostile. And it is remarkable that these hackers are now among Mac OS Xâs strongest adherents.
Itâs another sign of Mac OS Xâs dual nature: from the perspective of your typical user (and particularly long-time Mac users), it is the Mac OS with a modern Unix architecture encapsulated under the hood; from the perspective of the hackers Graham writes of, it is Unix with a vastly superior GUI.
Ajax, Hard Facts, Brass Tacks ... and Bad Slacks
<a>
and <form>
pack an enormous amount of functionality into deceptively simple tags, so too can new declarative mark-up capture patterns that have emerged 'in the wild'.
<form action=/search name=f>
<input type=hidden name=hl value=en>
<input maxLength=256 size=55 name=q value="">
<input type=submit value="Google Search" name=btnG>
</form>
<a>
and <form>
are pretty much the same thing.)
<xf:submission id="sub-search"
action="http://www.google.com/complete/search?hl=en"
method="get" separator="&"
replace="all"
/>
<xf:input ref="q">
<xf:label>Query:</xf:label>
</xf:input>
<xf:submit submission="sub-search">
<xf:label>Google Search</xf:label>
</xf:submit>
replace
attribute is actually optional in XForms, but I showed it in the previous mark-up so that you can compare it to this:
<xf:submission id="sub-search"
action="http://www.google.com/complete/search?hl=en"
method="get" separator="&"
replace="instance"
/>
replace
attribute can take the values all
, instance
, or none
.)
var req;
function loadXMLDoc(url) {
// native XMLHttpRequest object
if (window.XMLHttpRequest) {
req = new XMLHttpRequest();
req.onreadystatechange = readyStateChange;
req.open("GET", url, true);
req.send(null);
// IE/Windows ActiveX version
} else if (window.ActiveXObject) {
req = new ActiveXObject("Microsoft.XMLHTTP");
if (req) {
req.onreadystatechange = readyStateChange;
req.open("GET", url, true);
req.send();
}
}
}
readyStateChange()
method is invoked:
function readyStateChange() {
// '4' means document "loaded"
if (req.readyState == 4) {
// 200 means "OK"
if (req.status == 200) {
// do something here
} else {
// error processing here
}
}
}
<a>
in order to enter the exciting new world of 'hypertext' -- but XMLHttpRequest raises the bar again, and takes us right back into the heart of geek-world.
if (req.status == 200) {
// do something here
} else {
// error processing here
}
<xf:action ev:observer="sub-search" ev:event="xforms-submit-error">
<xf:message level="modal">
Submission failed
</xf:message>
</xf:action>
submission
part of XForms:multipart/related
;put
means the same thing whether the target URL begins http:
or file:
, a form with relative paths will run unchanged on a local machine or a web server;submission
element to read and write from an ADO database, allowing programmers to convert forms from using the web to using a local database by doing nothing more than changing a single target URL. (Try doing that with XMLHttpRequest!)submission
part of XForms is in fact so powerful that it will eventually form a separate specification, for use in other languages.<div>
, a CSS display: none;
, a mouseover
event handler and a timer? Nowadays the programmer with better things to do than work with spaghetti-JavaScript just uses the XForms <hint>
element, and for free they get platform independence (and therefore accessibility), as well as the ability to insert any mark-up.message
s?Here goes:
Blog Editing
I can use any editor that supports the following Blog Post APIs:
- Moveable Type
- Meta Weblog
- Blogger
Typically I use Virtuoso (which has an unreleased WYSIWYG blog post editor), Newzcrawler, ecto, Zempt, or w.bloggar for my posts. If a post is of interest to me, or relevant to our company or customers I tend to perform one of the following tasks:
- Generate a post using the "Blog This" feature of my blog editor
- Write a new post that was triggered by a previously read post etc.
Either way, the posts end up in our company wide blog server that is Virtuoso based (more about this below). The internal blog server automatically categorizes my blog posts, and automagically determines which posts to upstream to other public blogs that I author (e.g http://kidehen.typepad.com ) or co-author (e.g http://www.openlinksw.com/weblogs/uda and http://www.openlinksw.com/weblogs/virtuoso ). I write once and my posts are dispatched conditionally to multiple outlets.
RSS/Atom/RDF Aggregation & Reading
I discover, subscribe to, and view blog feeds using Newzcrawler (primarily), and from time to time for experimentation and evaluation purposes I use RSS Bandit, FeedDemon, and Bloglines. I am in the process of moving this activity over to Virtuoso completely due to the large number of feeds that I consume on a daily basis (scalability is a bit of a problem with current aggregators).
Blog Publishing
When you visit my blog you are experiencing the soon to be released Virtuoso Blog Publishing engine first hand, which is how WebDAV, SQLX, XQuery/XPath, and Free Text etc. come into the mix.
Each time I create a post internally, or subscribe to an external feed, the data ends up in Virtuoso's SQL Engine (this is how we handle some of the obvious scalability challenges associated with large subscription counts). This engine is SQL2000N based, which implies that it can transform SQL to XML on the fly using recent extensions to SQL in the form of SQLX (prior to the emergence of this standard we used the FOR XML SQL syntax extensions for the same result). It also has its own in-built XSLT processor (DB Engine resident), and validating XML parser (with support for XML Schema). Thus, my RSS/RDF/Atom archives, FOAF, BlogRoll, OPML, and OCS blog syndication gems are all live examples of SQLX documents that leverage Virtuoso's WebDAV engine for exposure to Blog Clients.
Blog Search
When you search for blog posts using the basic or advanced search features of my blog, you end up interacting with one of the following methods of querying data hosted in Virtuoso: Free Text Search, XPath, or XQuery. The result sets produced by the search feature uses SQLX to produce subscription gems (RSS/Atom/RDF/OpenSearch) and URIs that enable dynamic tracking of my posts using your search keywords.
BTW - the http://www.openlinksw.com/blog/~kidehen blog home page exists as a result of Virtuoso's Virtual Domain / Multi-Homing Web Server functionality. The entire site resides in an Object Relational DBMS, and I can take my DB file across Windows, Solaris, Linux, Mac OS X, FreeBSD, AIX, HP-UX, IRIX, and SCO UnixWare without missing a single beat! All I have to do is instantiate my Virtuoso server and my weblog is live.
]]>I also hope that Oracle will support Mono -off the bat- rather than taking the typical "we will port to Mono sometime in the future..." type message which will not be acceptable, especially as we pulled this off first time around in 2002 (as atop Mono then). Thus, I am sure they can do it in 2005 :-)
Hopefully we should be able to add Oracle 10g Release 2 and DB2 to our SQL CLR hosting features comparison document that currently only covers SQL Server 2005 and Virtuoso.
]]>
BTW - I took the time to update my public blog-he-roll and new blog-her-roll; both being tiny snapshots of my actual blog subscription collection, which by the way, is actually so large and diverse that it's part of an internal project covering distributed XQuery and scalability :-)
]]>Over at BB, Cory posts on Mark Pilgrim's hack "Butler" which strips out most Google ads, removes copying restrictions in Google Print, adds alternative search results to nearly every Google service, and generally does things which I can only imagine will keep give big G fits. It is still in geek stage - it requires "Greasemonkey" and Firefox - but man, it sure sounds like fun.
]]>Today is one of those days where one topic appears to be on the mind of many across cyberspace. You guessed right! Its that Web 2.0 thing again.
Paul Bausch brings Yahoo!'s most recent Web 2.0 contribution to our broader attention in this excerpt from his O'Reilly Network article:
I browse news, check stock prices, and get movie times with Yahoo! Even though I interact with Yahoo! technology on a regular basis, I've never thought of Yahoo! as a technology company. Now that Yahoo! has released a Web Services interface, my perception of them is changing. Suddenly having programmatic access to a good portion of their data has me seeing Yahoo! through the eyes of a developer rather than a user.
The great thing about this move by Yahoo! is two fold (IMHO):
The great thing about the Platform oriented Web 2.0 is the ability to syndicate your value proposition (aka products and services) instead of pursuing fallable email campaigns. It enables the auto-discovery of products and services by user agents (the content aspect). Web 2.0 also provides an infrastructure for user agents to enter into a consumptive interactions with discrete or composite Web Services via published endpoints exposed by a platform (the execution aspect).
A scenario example:
You can obtain RSS feeds (electronic product catalogs) from Amazon today, although you have to explicitly locate these catalog-feeds since Amazon doesn't exploit feed auto-discovery within their domain.
If you use Firefox or another auto-discovery supporting RSS/Atom/RDF user agent; visit this URL; Firefox users should simply click on the little orange icon bottom right of the browser's window to its RSS feed auto-discovery in action.
Anyway, once you have the feeds the next step is execution endpoints discovery within the Amazon domain (the conduits to Amazon's order processing system in this example). At the current time there isn't broad standardization of Web Services auto-discovery but it's certainly coming; WSIL is a potential front runner for small scale discovery while UDDI provides a heavier duty equivalent for larger scale tasks that includes discovery and other related functionality realms.
Back to the example trail, by having the RSS/Atom/RDF feed data within the confines of a user agent (an Internet Application to be precise) nothing stops the extraction of key purchasing data from these feeds, plus your consumer data en route to assembling an execution message (as prescribed by the schema of the service in question)for Amazon's order processing/ shopping cart service. All of this happens without ever seeing/eye-balling the Amazon site (a prerequisite of Web 1.0 hence the dated term: Web Site).
To summarize: Web 2.0 enables you to syndicate your value proposition and then have it consumed via Web Services, leveraging computer, as opposed to human interaction cycles. This is how I believe Web 2.0 will ultimately impact the growth rates (in most cases exponentially) of those companies that comprehend its potential.
]]>Anyway, back to cognitive dissonance. Could this be the reason for the following?
And more...
]]>Email As A Platform It looks like more people are starting to realize that email is more than it seems. Especially given the drastic increase in storage size of web-based email applications, more people are realizing that email is basically a personal database. People simply store information in their email, from contact information that was emailed to them to schedule information to purchase tracking from emailed receipts. Lots of people email messages to themselves, realizing that email is basically the best "permanent" filing system they have. That's part of the reason why good email search is so important. Of course, what the article doesn't discuss is the next stage of this evolution. If you have a database of important information, the next step is to build useful applications on top of it. In other words, people are starting to realize that email, itself, is a platform for personal information management.
Answers.com was launched a month ago, and its stock is practically on fire! Does this graph tell you anything about subject searches vs keyword searches?
The burgeoning Semantic Web will disrupt the search market in a big way (and for the better IMHO).
]]>
An immediate implication is that you can generate Google AdWords based adds using any development environment (Virtuoso's SQL Stored Procedure Language, any .NET bound language, Java, C/C++, PHP, Ruby, Perl, Python, TCL etc.) that supports SOAP, WSDL, and I would presume WS-Security.
An even more interesting offshoot of this initiative from Google, is the fact that it could bring a degree of clarity to the issue of multi-protocol and multi-purpose servers (what I call Universal Servers e.g. OpenLink Virtuoso). For instance, you could manage AdWords campaigns across product portfolios using Triggers (the SQL database kind) or Notification Services.
]]>By Ingo Rammer, Microsoft MSDN Library.
In this article the author shows how you can create and use a custom security token manager with the Web Services Enhancements 2.0 for Microsoft .NET to check for X.509 certificates, map them to roles and populate context information with custom principal and identity objects.
He shows how easy it is to use WS-Policy from within Visual Studio .NET to add declarative checking of role membership to your applications. The advantage of this approach based on WS-Security when compared to classic HTTP based security is that it doesn't rely on transport-level integrity or security but instead works solely with the SOAP message. This provides you with end-to-end security capabilities over multiple hops and protocols.
http://msdn.microsoft.com/library/en-us/dnwse/html/wserolebasedsec.asp
See also WS-Security references: http://xml.coverpages.org/ws-security.html
]]>From their web site:
At Glance Networks, we believe people need a simple way to work together at a distance.
Each day, people send billions of emails and faxes to each other. They talk together on phone for billions of minutes. While there is always a need for improved communication tools, traditional web and video conferencing solutions are often too complex, too over-featured and too expensive. Customers want a solution they can master in under a minute. It must connect instantly and reliably to anyone from anywhere on the Internet.
To that end, we built a simple, affordable service for showing live PC screens over the Internet.Phone any friend or business associate and click Glance to show them your live PC screen. Demonstrate your software. Go over a spreadsheet. Give a presentation. Show a design. Review a document. Provide technical help. Close a sale. Every mouse movement and screen update you see, they see.
Cool! Imagine a fusion of this technolgy with Skype
]]>Since last fall, I've been recommending Bloglines to first-timers as the fastest and easiest introduction to the subscription side of the blogosphere. Remarkably, this same application also meets the needs of some of the most advanced users. I've now added myself to that list. Hats off to Mark Fletcher for putting all the pieces together in such a masterful way.
What goes around comes around. Five years ago, centralized feed aggregators -- my.netscape.com and my.userland.com -- were the only game in town. Fat-client feedreaders only arrived on the scene later. Because of the well-known rich-versus-reach tradeoffs, I never really settled in with one of those. Most of the time I've used the Radio UserLand reader. It is browser-based, and it normally points to localhost, but I've been parking Radio UserLand on a secure server so that I can read the feeds it aggregates for me from anywhere.
Bloglines takes that idea and runs with it. Like the Radio UserLand reader, it supports the all-important (to me) consolidated view of new items. But its two-pane interface also shows me the list of feeds, highlighting those with new entries, so you can switch between a linear of scan of all new items and random access to particular feeds. Once you've read an item it vanishes, but you can recall already-read items like so:
If a month's worth of some blog's entries produces too much stuff to easily scan, you can switch that blog to a titles-only view. The titles expand to reveal all the content transmitted in the feed for that item.
I haven't gotten around to organizing my feeds into folders, the way other users of Bloglines do, but I've poked around enough to see that Bloglines, like Zope, handles foldering about as well as you can in a Web UI -- which is to say, well enough. With an intelligent local cache it could be really good; more on that later.
Bloglines does two kinds of data mining that are especially noteworthy. First, it counts and reports the number of Bloglines users subscribed to each blog. In the case of Jonathan Schwartz's weblog, for example, there are (as of this moment) 253 subscribers.
Second, Bloglines is currently managing references to items more effectively than the competition. I was curious, for example, to gauge the reaction to the latest salvo in Schwartz's ongoing campaign to turn up the heat on Red Hat. Bloglines reports 10 References. In this case, the comparable query on Feedster yields a comparable result, but on the whole I'm finding Bloglines' assembly of conversations to be more reliable than Feedster's (which, however, is still marked as 'beta'). Meanwhile Technorati, though it casts a much wider net than either, is currently struggling with conversation assembly.
I love how Bloglines weaves everything together to create a dense web of information. For example, the list of subscribers to the Schwartz blog includes: judell - subscribed since July 23, 2004. Click that link and you'll see my Bloglines subscriptions. Which you can export and then -- if you'd like to see the world through my filter -- turn around and import.
Moving my 265 subscriptions into Bloglines wasn't a complete no-brainer. I imported my Radio UserLand-generated OPML file without any trouble, but catching up on unread items -- that is, marking all of each feed's sometimes lengthy history of items as having been read -- was painful. In theory you can do that by clicking once on the top-level folder containing all the feeds, which generates the consolidated view of unread items. In practice, that kept timing out. I finally had to touch a number of the larger feeds, one after another, in order to get everything caught up. A Catch Up All Feeds feature would solve this problem.
Another feature I'd love to see is Move To Next Unread Item -- wired to a link in the HTML UI, or to a keystroke, or ideally both.
Finally, I'd love it if Bloglines cached everything in a local database, not only for offline reading but also to make the UI more responsive and to accelerate queries that reach back into the archive.
Like Gmail, Bloglines is the kind of Web application that surprises you with what it can do, and makes you crave more. Some argue that to satisfy that craving, you'll need to abandon the browser and switch to RIA (rich Internet application) technology -- Flash, Java, Avalon (someday), whatever. Others are concluding that perhaps the 80/20 solution that the browser is today can become a 90/10 or 95/5 solution tomorrow with some incremental changes.
Dare Obasanjo wondered, over the weekend, "What is Google building?" He wrote:
In the past couple of months Google has hired four people who used to work on Internet Explorer in various capacities [especially its XML support] who then moved to BEA; David Bau, Rod Chavez, Gary Burd and most recently Adam Bosworth. A number of my coworkers used to work with these guys since our team, the Microsoft XML team, was once part of the Internet Explorer team. It's been interesting chatting in the hallways with folks contemplating what Google would want to build that requires folks with a background in building XML data access technologies both on the client side, Internet Explorer and on the server, BEA's WebLogic. [Dare Obasanjo]It seems pretty clear to me. Web applications such as Gmail and Bloglines are already hard to beat. With a touch of alchemy they just might become unstoppable.
Do you have an idea that you think others might be able to solve?
Make a LazyWeb request by writing it on your own blog, and then sending a Trackback ping to the new url: http://www.lazyweb.org/lazywebtb.cgi
Just linking to this page usually works. The LazyWeb links back to you, so make sure you have somewhere for people to leave comments.
Cool!
]]>Mac OS X Tiger is a copycat, claims developer While Apple is expecting Microsoft to mimic Mac OS X 10.4 Tiger, one developer says the new Mac operating system is the one doing the copying... [via MacMinute]
A more important aspect of this post is the changing face of the Web Client/ OS. What I mean by this is the gradual decomposition of the user agent monlith (browser for instance) into composite services that will increasing communicate with services over the net.
]]>Will .Net Developers Get Mono? Novell has released a new version of Mono -- an open-source implementation of Microsoft's .Net framework -- and some early adopters are already singing its praises. "Mono makes Novell extremely relevant now," said Kingsley Idehen, president and CEO of OpenLink, which has just released Virtuoso 3.5, a database-oriented middleware product that was built using Mono.
I meant making
]]>Enjoy!
Questions about Longhorn, part 3: Avalon's enterprise mission
The slide shown at the right comes from a presentation entitled Windows client roadmap, given last month to the International .NET Association (INETA). When I see slides like this, I always want to change the word "How" to "Why" -- so, in this case, the question would become "Why do I have to pick between Windows Forms and Avalon?" Similarly, MSDN's Channel 9 ran a video clip of Joe Beda, from the Avalon team, entitled How should developers prepare for Longhorn/Avalon? that, at least for me, begs the question "Why should developers prepare for Longhorn/Avalon?"
I've been looking at decision trees like the one shown in this slide for more than a decade. It's always the same yellow-on-blue PowerPoint template, and always the same message: here's how to manage your investment in current Windows technologies while preparing to assimilate the new stuff. For platform junkies, the internal logic can be compelling. The INETA presentation shows, for example, how it'll be possible to use XAML to write WinForms apps that host combinations of WinForms and Avalon components, or to write Avalon apps that host either or both style of component. Cool! But...huh? Listen to how Joe Beda frames the "rich vs. reach" debate:
Avalon will be supplanting WinForms, but WinForms is more reach than it is rich. It's the reach versus rich thing, and in some ways there's a spectrum. If you write an ASP.NET thing and deploy via the browser, that's really reach. If you write a WinForms app, you can go down to Win98, I believe. Avalon's going to be Longhorn only.So developers are invited to classify degrees of reach -- not only with respect to the Web, but even within Windows -- and to code accordingly. What's more, they're invited to consider WinForms, the post-MFC (Microsoft Foundation Classes) GUI framework in the .NET Framework, as "reachier" than Avalon. That's true by definition since Avalon's not here yet, but bizarre given that mainstream Windows developers can't yet regard .NET as a ubiquitous foundation, even though many would like to.
Beda recommends that developers isolate business logic and data-intensive stuff from the visual stuff -- which is always smart, of course -- and goes on to sketch an incremental plan for retrofitting Avalon goodness into existing apps. He concludes:
Avalon, and Longhorn in general, is Microsoft's stake in the ground, saying that we believe power on your desktop, locally sitting there doing cool stuff, is here to stay. We're investing on the desktop, we think it's a good place to be, and we hope we're going to start a wave of excitement leveraging all these new technologies that we're building.It's not every decade that the Windows presentation subsystem gets a complete overhaul. As a matter of fact, it's never happened before. Avalon will retire the hodge-podge of DLLs that began with 16-bit Windows, and were carried forward (with accretion) to XP and Server 2003. It will replace this whole edifice with a new one that aims to unify three formerly distinct modes: the document, the user interface, and audio-visual media. This is a great idea, and it's a big deal. If you're a developer writing a Windows application that needs to deliver maximum consumer appeal three or four years from now, this is a wave you won't want to miss. But if you're an enterprise that will have to buy or build such applications, deploy them, and manage them, you'll want to know things like:
How much fragmentation can my developers and users tolerate within the Windows platform, never mind across platforms?
Will I be able to remote the Avalon GUI using Terminal Services and Citrix?
Is there any way to invest in Avalon without stealing resources from the Web and mobile stuff that I still have to support?
Then again, why even bother to ask these questions? It's not enough to believe that the return of rich-client technology will deliver compelling business benefits. (Which, by the way, I think it will.) You'd also have to be shown that Microsoft's brand of rich-client technology will trump all the platform-neutral variations. Perhaps such a case can be made, but the concept demos shown so far don't do so convincingly. The Amazon demo at the Longhorn PDC (Professional Developers Conference) was indeed cool, but you can see similar stuff happening in Laszlo, Flex, and other RIA (rich Internet application) environments today. Not, admittedly, with the same 3D effects. But if enterprises are going to head down a path that entails more Windows lock-in, Microsoft will have to combat the perception that the 3D stuff is gratuitous eye candy, and show order-of-magnitude improvements in users' ability to absorb and interact with information-rich services.
In section, 4.1 Human-friendly Syntax, you say "There must be a text-based form of the query language which can be read and written by users of the language", and you list the status as "pending".
As background for section 4.1, you may be interested in RDFQueryLangComparison1 (original text replaced with live link).
It shows how to write queries in a form that includes English meanings.
The example queries can be run by pointing a browser to www.reengineeringllc.com .
Perhaps importantly, given the intricacy of RDF for nonprogrammers, one can get an English explanation of the result of each query.
-- Dr. Adrian Walker of Internet Business Logic
The Semantic Web continues to take shape, and Infonauts (information centric agents) are already taking shape.
A great thing about the net is the "back to the future" nature of most Web and Internet technology. For instance we are now frenzied about Service Oriented Architecture (SOA), Event Drivent Architecture (EDA), Loose Coupling of Composite Services etc. Basically rehashing the CORBA vision.
I see the Semantic Web playing a similar role in relation to artificial intelligence.
BTW - It still always comes down to data, and as you can imagine Virtuoso will be playing its usual role of alleviating the practical implementation and ulization challenges of all of the above :-)
]]>
In section, 4.1 Human-friendly Syntax, you say "There must be a text-based form of the query language which can be read and written by users of the language", and you list the status as "pending".
As background for section 4.1, you may be interested in RDFQueryLangComparison1 (original text replaced with live link).
It shows how to write queries in a form that includes English meanings.
The example queries can be run by pointing a browser to www.reengineeringllc.com .
Perhaps importantly, given the intricacy of RDF for nonprogrammers, one can get an English explanation of the result of each query.
-- Dr. Adrian Walker of Internet Business Logic
The Semantic Web continues to take shape, and Infonauts (information centric agents) are already taking shape.
A great this about the net is the "back to the future" nature of most Web and Internet technology. For instance we are now frenzied about Service Oriented Architecture (SOA), Event Drivent Architecture (EDA), Loose Coupling of Composite Services etc. Basically rehashing the CORBA vision.
I see the Semantic Web playing a similar role in relation to artificial intelligence.
BTW - It still always comes down to data, and as you can imagine Virtuoso will be playing its usual role of alleviating the practical implementation and ulization challenges of all of the above :-)
]]>
By David Mertz, IBM developerWorks
In Part 2 of a serial article on GUIs and XML configuration data, David discusses how XML is used in the configuration of GUI interfaces. He looks at Mozilla's XML-based User Interface Language (XUL) which allows you to write applications that run without any particular dependency on the choice of underlying operating system. This may seem strange at first, but you'll soon see that this Mozilla project offers powerful tools for GUI building that allow you to develop for an extensive base of installed users. Mozilla is now much more than a browser: it is a whole component and GUI architecture. Indeed, Mozilla is more cross-platform and more widely installed on user systems than probably any other GUI library you are likely to consider. What you might think of as general purpose GUI/widget libraries -- Qt, wxWindows, GTK, FOX, MFC, .NET, Carbon, and so on -- have various advantages and disadvantages. But none of them can be assumed to be already installed across user systems. Many of them are only available on a subset of the platforms Mozilla supports, and most are relatively difficult to install or have licensing issues. Mozilla is worth installing just because it is such a great browser; once you have it, you have a free platform for custom applications. To be completely cross-platform in your Mozilla/XUL applications, you need to restrict yourself to configuring GUIs in XUL and programming their logic in JavaScript.
http://www-106.ibm.com/developerworks/library/x-matters35/
See also XUL References: http://xml.coverpages.org/xul.html
]]>How secure is your data? Looking at your information management resources through a would-be intruder's eyes can help you find (and fix) vulnerabilities.
Naturally :-)
When E. F. Codd developed his relational data model in 1970, the business world was a different place. Almost 35 years after his seminal work appeared, RDBMSs that sprung from Codd's ideas are the standard for storing corporate information. And, with government and industry regulations dictating what kinds of information companies have to store, manage, and audit (and for how long), protecting this information is more important than ever. Unfortunately, it's also more challenging
Even in 1985, when Dr. Codd published 12 guidelines for RDBMSs, there was little concern for data security. In those days, gaining access to a database was so difficult that advanced security features on the database were irrelevant.
Today, RDBMSs carry the lifeblood of every organization. Note the use of the plural: Organizations now have many databases that are decentralized in terms of use and security controls. E-business demands that data access be extended to customers, partners, suppliers, and other parties who were rarely considered in the early data management days. With all this availability ? not to mention pressure from an array of government and industry regulations (see the sidebar, "Security and Compliance") ? the need to control exactly who can access or modify data is becoming paramount.
Absolute facts, that are still partially understood at best. For instance we are still in a so called "Information Age" in which standards based data access remains an issue of contempt instead of absolute necessity.
There are a number of prevailing myths about standards based data access that continue to cloak reality:
Even if the above were true (which I refute strongly), how about the general security vulnerabilities that affect both Native, and Standards compliant, data access interfaces?
Aaron's article does a good job of highlighting 6 areas of vulnerability:
What I have been able to do very quickly (thanks to blogging, and the power of a blog engine that supports WebDAV), is write a tabulated response to each of the items (bar Fixpaks) indicating how the OpenLink Multi-Tier Data Access Drivers (for ODBC, JDBC, ADO.NET, and OLEDB) protect corporate databases from each of these vulnerabilities.
To cut a long story short, we are increasingly living a contradiction where the terms "simple" and "free" are supposed to lead us to products that can adequately handle the challenges of an increasingly sophisticated grid of inter-connecting point.
I have been asked on numerous occassions, "How can you build a company and business based on data access technology?". My reply is the same as usual, "because everything comes down to data". If the data is compromised in anyway, then kiss Information, Knowledge, and everything else goodbye!
]]>
This issue really brings WebDAV into scope as this is the protocol that enables this capability (as covered by Jon's piece), and it is one of the many client and server side protocols implemented by OpenLink Virtuoso (the key to how Virtuoso delivers URI based SQL-XML, XQuery, XPath services).
When you install Virtuoso you simply have to start the Virtuoso server instance to the get WebDAV functionality going. All of Virtuoso's services are advertised at ports, and in the case of WebDAV you will find this at port 8890 if you start the demo database.
To exploit the Virtuoso/WebDAV server from any WebDAV client (or point urls at WebDAV hosted resources) simply do the following:
BTW - This blog is WebDAV based (it's a live instance of Virtuoso doing many things; WebDAV, HTTP, SQL-XML based feed generation for ATOM, RSS, Blog Post APIs support (Moveable Type, Metaweblog, Blogger, ATOM), Free Text, XPath, XQuery, and more).Â
]]>Brady Anderson has released the first version of his multicast DNS responder written in C# for the Mono and .NET platforms. This is the foundation for implementing rendezvous-like functionality in your applications. [via Mono Project News]
This is an example of Open Source adding a critical pieces of infrastructure to .NET that doesn't currently exist (in a sense an embrace and extend). The community isn't waiting for a .NET Frameworks implementation to clone, instead it has implemented this using Mono, which by implication means availability under Microsoft .NET.
]]>By Nigel McFarlane, devX.com
Microsoft's XAML markup language floats on top of the .NET platform. It is compiled into .NET classes, usually C#, which reduces it to a set of objects. Along with a host of other XML dialects it is an example of a new type of specification for GUIs.
This article takes a look at XAML's tags to see what (if anything) is new in them. There are many such GUI specifications now, a few being Mozilla's XUL, Oracle's UIX, Macromedia's Flex and the XML files created by the Gnome Glade tool. Although not W3C standards, some of these new GUI specifications are already on the W3C standards track. An example is the box model used within Mozilla's XUL, which is headed toward inclusion in future CSS drafts.
The original and most popular source of XML definitions is, however, still the World Wide Web Consortium. The W3C is responsible for formalizing XML and many XML applications such as XHTML and SVG. Given that these standards are mostly complete, do we really need all these new XML GUI dialects?
Microsoft's XAML is a new spin on XML-based GUI description languages, borrowing very little syntax from established standards. Let's see if it's a radical improvement in some way, or if it's merely familiar old friends dressed up in new clothes.
http://www.devx.com/webdev/Article/20834
See also XAML References: http://xml.coverpages.org/ms-xaml.html
]]>I hope to do a new snapshot in the first week of May and after that to work towards the 0.8 release.
As I completed this post a bell went off! Why not use this for a quick live demo of Virtuoso's hosting capabilities? Starting off with something simple like PHP for instance?
So, I quickly did the following:
So we all buy and deploy copies of InfoPath, and then get rid of our non SQL Server and ACCESS databases? Wow!
How about InfoPath emitting XForms compliant forms? Even better, what about
]]>So we all buy and deploy copies of InfoPath, and then get rid of our non SQL Server and ACCESS databases? Wow!
How about InfoPath emitting XForms compliant forms? Even better, what about
]]>Will SQL Become The ETL Language Of Choice?
Will SQL replace proprietary tool languages as the ETL language of choice? Yves de Montcheuil asks this question over at DMReview.com.
]]>By Lars Marius Garshol, Ontopia Technical Report
Information Architecture is the discipline dealing with the modern version of this problem: how to organize web sites so that users actually can find what they are looking for. Information architects have so far applied known and well-tried tools from library science to solve this problem, and now topic maps are sailing up as another potential tool for information architects. This raises the question of how topic maps compare with the traditional solutions. The paper argues that topic maps go beyond the traditional solutions in the sense that it provides a framework within which they can be represented as they are, but also extended in ways which significantly improve information retrieval. The paper tries to show that topic maps provide a common reference model that can be used to explain how to understand many common techniques from library science and information architecture.
http://www.ontopia.net/topicmaps/materials/tm-vs-thesauri.html
See also (XML) Topic Maps:
http://xml.coverpages.org/topicMaps.html]]>]]>"The enormity of the impact that this company has had on the way everything that is printed is produced cannot be measured," said Christopher Galvin, an analyst with Hambrecht & Quist LLC in San Francisco. And Geschke himself points out that this sphere of influence now includes Hollywood, television and, of course, the Internet.
Armed with his childhood penchant for disassembling the family's appliances and a trio of college degrees, he wound up at Xerox Corp.'s famed Palo Alto Research Center (PARC), a breeding ground for inventions that seemingly made billions for everyone except Xerox. He hired Warnock in 1978 and in 1980 founded PARC's Imaging Sciences Laboratory with the mission of marrying computer technology to Xerox's legacy printing products. The duo's Interpress page-description language became Xerox's internal standard, but the company refused to license it to others.
Frustrated with the inability to publicly showcase their creation, Geschke and Warnock left PARC and started Adobe in 1982, naming the fledgling company after the creek running behind Warnock's house. The original mission, Warnock recalled, was to go into a service business, "kind of like what Kinko's is today."
We have got to take time to understand the Data Access Layer, if we don't we will utlimately pay a hefty price (IMHO).
This blog post is also hillarious, especially if you have encountered the mercurial "Murphy" during live product demos.
So, today I went to hell. And then I came back. It was a short trip.
This year, I am giving a presentation on Mono at Brainshare in Salt Lake City, an intro to Mono for developers. I got a pretty good turnout with a few ximian people in the back (including Joe whom I saw for the first time without a hat).
So I plug in my PowerBook 12" as I always do but for some reason I have a hard time getting the projector to display its output. After struggling a little I resort to using the desktop provided by Novell, running Ximian Desktop 2 (and some version Suse Linux).
So I upload my presentation to www.frenchguys.com from my mac and then download it back to the desktop. Now I can make my presentation, which goes well. Then I get to a slide that just says : DEMO. Hmmm. Demo. I don't have Mono installed on that generic machine I was just given. I am going to need magic. So to magic I resort.
[via Monologue]
]]>
Aparna Jairam |
Shirley Turner |
I toss a slur across her desk. I call her a protectionist.
"Oh, and I'm proud of it," she responds. "I wear that badge with honor. I am a protectionist. I want to protect America. I want to protect jobs for Americans."
"But isn't part of this country's vitality its ability to make these kinds of changes?" I counter. "We've done it before - going from farm to factory, from factory to knowledge work, and from knowledge work to whatever's next."
She looks at me. Then she says, "I'd like to know where you go from knowledge." [Wired: Kiss Your Cubicle Goodbye]
Where indeed? I think protectionism is the wrong approach. And I think Dick Cook's ideas are right. But let's not kid ourselves. What's at stake here isn't just call-center jobs, or mind-numbing code-writing jobs, or accounting jobs. Creativity, innovation and hard work are the levers that move the global economy, and anybody, anywhere, will be able to grasp those levers. [via Jon's Radio]
As for the question posed at the end of the article; where do we go "beyond knowledge?" I have a simple answer -
]]>Man this is interesting. Is Dave Winer getting into the idea of ontology merging? Read this comment and judge for yourself:
?The hierarchy itself is separate ? you (could) publish an OPML file of that hierarchy and put it in a public place.
In answering the question, ?Why do it this way?? Dave gave an interesting response ? the atomization of a blog into feeds would allow users to merge the ?my world? of their blog with content from the many ?their worlds? on the net. Such merged topical hierarchies could then themselves be exported as an OPML file and a defacto statement of ?this is my point of view, my information and other information from beyond my domain that I think is important.?
There?s a number of folk hard at work on this problem: the XFML folks, Paolo Valdemarin & Matt Mower on their k-collector, and our very own SWAD-E thesaurus project which discusses mapping issues . Heck, we even discussed the issue in our requirements specification. All at different levels of sophistication and complexity. I suspect that something as simple as blog categorization won't run into the really hard thesaurus mapping problems, but that it won?t be straightforward as Dave?s comments might lead one to think.
To expand on this theme, let?s think about how people might want to share categories. Firstly, you might want to simply reuse someone else?s categorization scheme. That?s fine as a bootstrap, but what if you already have a scheme? What if the 2 schemes overlap? What happens to your previously categorized blog entries? You might, I suggest, want at least the ability to say ?these two categories are the same?.
Then there?s the aggregation of categories. Without some sort of mapping, two blogs using different categorization schemes are just that ? 2 blogs.
A feasible approach is the decentralized ontology creation favoured by Topic Exchange and k-collector. Here, people suggest new topics/categories, and the (ever growing) structure is shared among the community. A fine idea, but one I fear is not scaleable beyond a very small community.
Finally, there is the idea of ?semantic lenses? ? using 2 different categorization schemes to view the same content.
Oh, one other thing. Reading on, I note ?Dave?s idea is that supporting views other than reverse-chron gives new participants entry points into the data?. I couldn?t agree more, this is what I was trying to demonstrate with semantic view, navigation and query on the semantic blogging prototype.
]]>MySQL and the GPL Interesting read and thoughts and discussion about MySQL and "their" interpretation (backed by FSF) of the GPL on Sterling's Blog
Unfortunately I couldn't locate the Kingsley Idehen vs. Richard Stallman FreeODBC mailing list debate archive re. iODBC anywhere on the net, so this interview link will have to suffice).
note: ODBC Driver developers that use the 4.1 client libraries are "derivative work" and they will have to release source code which means we won't be updating our MySQL ODBC Drivers because we won't be forced into release the source code of our ODBC Drivers.
Databases get a grip on XML
From Inforworld.
The
next iteration of the SQL standard was supposed to arrive in 2003. But
SQL standardization has always been a glacially slow process, so nobody
should be surprised that SQL:2003 ? now known as SQL:200n ? isn?t ready
yet. Even so, 2003 was a year in which XML-oriented data management,
one of the areas addressed by the forthcoming standard, showed up on
more and more developers? radar screens.ÃÂ >> READ MORE
This article rounds up product for 2003 in the critical area of Enterprise Database Technology. It's certainly provides an apt reflection of how Virtuoso compares with offerings from some the larger (but certainly slower to implement) database vendors in this space. As usual Jon Udell's quote pretty much sums this up:
"While the spotlight shone on the heavyweight contenders, a couple of agile innovators made noteworthy advances in 2003. OpenLink Software?s Virtuoso 3.0, which we reviewed in March, stole thunder from all three major players. Like Oracle, it offers a WebDAV-accessible XML repository. Like DB2 Information Integrator, it functions as database middleware that can perform federated ?joins? across SQL and XML sources. And like the forthcoming Yukon, it embeds the .Net CLR (Common Language Runtime), or in the case of Linux, Novell/Ximian?s Mono."
Albeit still somewhat unknown to the broader industry we have remained true our "innovator" discipline, which still remains our chosen path to market leadership. Thus, its worth a quick Virtuoso release history, and featuresÃÂ recap as we get set to up the ante even further in 2004:
1998 - Virtuoso's initial public beta release with functional emphasis on Virtual Database Engine for ODBC and JDBC Data Sources.
1999 - Virtuoso's official commercial release, with emphasis stillÃÂ on Virtual Database functionality for ODBC, JDBC accessible SQL Databases.
2000 - Virtuoso 2.0 adds XML Storage, XPath, XML Schema, XQuery, XSL-T, WebDAV, SOAP, UDDI, HTTP, Replication, Free Text Indexing (*feature update*), POP3, and NNTP support.
2002 - Virtuoso 2.7 extends Virtualization prowess beyond data access via enhancements to its Web Services protocol stack implementation by enabling SQL Stored Procedures to be published as Web Services. It also debutsÃÂ its Object-Relational engine enhancements that include theÃÂ incorporation of Java and Microsoft .NET Objects into its User Defined Type, User Defined Functions, and Stored ProcedureÃÂ offerings.
2003 - Virtuoso 3.0 extends data and application logic virtualization into the Application Server realm (basically a Virtual Application server too!), by adding support for ASP.NET, PHP, Java Server Pages runtime hosting (making applications built using any of these languages deployable using Virtuoso across all supported platforms).
Collectively each of these releases have contributed to a very premeditated architecture and vision that will ultimately unveil the inherent power of critical I.S infrastructure virtualizationÃÂ along the following lines; data storage, data access , and application logic via coherent integration of SQL, XML, Web Services, and Persistent Stored Modules (.NET, Java, and other object based component building blocks).
ÃÂ
]]>I've been talking a lot about Mono.Security but until today I didn't realize that it was never officially introduced - at least in my blog.
The only existing introduction is the Mono's Crypto status page - which BTW is a great place to learn what's in and/or out Mono's cryptography.
<lazy-geek:copy-n-paste>
Rational: This assembly provides the missing pieces to .NET security. On Windows CryptoAPI is often used to provide much needed functionalities (like some cryptographic algorithms, code signing, X.509 certificates). Mono, for platform independence, implements these functionalities in 100% managed code.
</ lazy-geek:copy-n-paste>
The most important piece of information is 100% managed code. This means that Mono.Security isn't tied to the Mono runtime and/or specific class library - you're free (really it's MIT X11 licensed) to use it on any runtime you choose.
StructuresSystem.Security.Cryptography.Pkcs
in .NET 1.2;So the big, anticipated, questions were:
but Miguel's question was subtler "How mature are Mono Security classes?" There's no quick answer to that one.
So there's still a lots of stuff to do! Luckily I expect most of it to be pure fun :-).
Please report to me if you're using the classes in your own projects - I know may do ;-). I'd like bug reports and/or comments about your experience with Mono.Security. Kittens would also appreciate for sure...
02 Dec 2003: Mono 0.29 has been released
This release took us a long time to go out, but it is pretty exciting, with PPC supported. The best Mono release ever! [via Monologue]
This time last year Mono enabled us to deliver a release of Virtuoso that unveiled the power of .NET integration as a database extension mechanism on Windows and Linux along the following lines; User Defined Types, User Defined Functions, and Stored Procedures using any .NET bound language. It also enabled the deployment of ASP.NET applications on Linux, and on Windows without IIS. One item missing from my check list at the time was a Virtuoso release for Mac OS X with identical functionality.
This announcement implies we are within striking distance of a Virtuoso 3.2 release that enables .NET classes and frameworks utilization (along the lines described above) on Mac OS X.
]]>]]>RSS information routers will emerge in 2004 with the following characteristics:
? Persistent storage of XHTML full-text/graphics/audio/video of RSS feeds
? XPATH search across local and Net stores
? Self-forming and reordering subscriptions lists based on the aggregated priorities of user-chosen domain experts
? Use of IM notification for post notification to aggregate affinity groups and active conversations
? Integration of Hydra-like collaborative tools for multi-author conference transcripts
? Videoconferencing routing and broadcast/recording tools
? Integration of speech recognition and real-time indexing to allow quoting of linear audio and video streams
? Mesh networked peer-to-peer synchronization engine for item propagation across shared spaces on multiple clients, including phones; iPods; and eventually Longhorn PDAs (circa 2006).Armed with these tools, new industries will emerge in rapid succession:
? Metadata-driven directories that dynamically create RSS feeds based on affinity
? Virtual conferences
? IM/RSS presence networks for rich collaboration and e-mail replacement
? Content-generation tools based on small, routable XHTML objects
? A DRM network with enough creative and hardware support to blunt the Microsoft/RIAA DRM threat to peer-to-peer port hijacking.
It starts here with one of many excerpts from Scoble's blog:
Dave Winer, Jon Udell, and now Gerald Bauer says that Microsoft is killing the Web. Or trying to.
The guys above are pretty seasoned individuals (they save me a lot of writing too amongst other things).
Now here is a response from Microsoft?s Blog evangelist supremo Scoble to their comments and genuine concerns.
OK, let's assume that's true.
Microsoft has 55,000 employees. $50 billion or so in the bank.
Yet what has gotten me to use the Web less and less lately? RSS 2.0.
Seriously. I rarely use the browser anymore (except to post my weblog since I use Radio UserLand).
See the irony there? Dave Winer (who at minimum popularized RSS 2.0) has done more to get me to move away from the Web than a huge international corporation that's supposedly focused on killing the Web.
Now, let's look at what's really going on here. We're going back to being a great platform company. We're trying to provide a platform that lets developers build new applications that are impossible to build on other platforms. At the PDC you saw some of that. New kinds of forms. New kinds of games. New kinds of business apps. New kinds of experiences.
But, we also are looking for ways to make the Web better too. Now, we haven't talked about what we're doing with the browser. I hear that'll come later. Astute Longhorn testers have already seen that we snuck a pop-up ad blocker into the browser without telling anyone about it. Whoa. That means we're gonna turn off MSN's capabilities of selling popup ads.
I hear there's more coming too. But, why should we do it all? Wasn't the point of the past four years to get Microsoft to stop trying to do it all? The DOJ and now the European Union are still after us cause we tried to do it all. Instead, let's just go back and be a great platform company.
We just gave you a great foundation for a killer new kind of application. One that goes FAR beyond HTML. And, even if you stick with Mozilla, your experiences on Longhorn will get better. For instance, fonts are being rendered in the GPU now on Longhorn. Your Web pages will look better and behave better on Longhorn than they will on any other platform. Period.
And wait until Mozilla's and other developers start exploiting things like WinFS to give you new features that display Internet-based information in whole new ways.
If Microsoft really wants to create a better platform shouldn?t this be truly futuristic? If so, then it should issue the first major salvo by dropping the restrictions on Rotor?
We are moving into the distributed component based computing age where runtime environments (.NET CLR, Mono, J2EE, and others) act a Component Execution Junction boxes (instead of the Monolithic Operating Systems of today) in a continuum of services orchestrated by messages in response to events emanating from value consumption requests (what we call application behviour today) from a myriad of value consumers (application users).
There is no need for covert and protracted protection of an obsolete Windows Operating System (the underlying fear that keeps Rotor shackled in my opinion), since its obsolescence is in full motion as Longhorn clearly demonstrates.
Imagine a fusion of sorts across Microsoft .NET, Mono, and Rotor, with a single portable runtime as the end product (slotting nicely into its place in the imminent distributed component and services era). All the benefits of programming language independence in true glory - the ECMA-CLI is all about programming language independence. Now that would be unequivocally revolutionary, and Microsoft would actually be doing what I think it has been desperately trying to achieve for a long time; the delivery of really cool technology that seriously impact us all in a positive way without the usual World Domination Concerns.
Anyway, back to the current reality where we have covert attempts to lock us all into Windows getting more and more transparent per technology release cycle. The very antithesis of what I espoused in the last paragraph (or dream). I believe that Scoble's instincts lie in this realm too, and you never know this evangelist may turn Messiah :-)
Here's the final excerpt from Scoble?s post:
There's a whole lot of more useful stuff coming. Both for the Web and for newer Internet-centric rich-client approaches. Personally, it's about time. I'm already using the Web less and less thanks to things like RSS 2.0.
I'm watching 636 sites every day. Try to do THAT in your Web browser.
So, yes, blame it on me. I'm trying to kill the Web. Isn't it time to move on? Didn't we move on from the Apple II? Didn't we move on from DOS? Didn't we move on from Windows 3.11? Can't you see a day when we move on from the Web and get something even more fantastic? I can. Dave Winer can. Why not you? [via The Scobleizer Weblog]
If you kill the Web en route to getting us a Portable Execution Junction box from Microsoft, I think you would have served mankind pretty damned well. We won't have to gripe about Web 1.0 (Browser Driven Web) because we would be well into Web 2.0 and beyond (which doesn?t define the Web experience predominantly via browsing).
]]>
Reading the Longhorn SDK docs is a disorienting experience. Everything's familiar but different. Consider these three examples:
[Full story: Replace and defend via Jon's Radio]
"Replace & Defend" is certainly a strategy that would have awakened the entire non Microsoft Developer world during the recent PDC event. I know these events are all about preaching to the choir (Windows only developers), but as someone who has worked with Microsoft technologies as an ISV since the late 80's there is something about this events announcements that leave me concerned.
Ironically these concerns aren't about the competitive aspects of their technology disruptions, but more along the lines of how Microsoft (I hope inadvertently) generates the kinds of sentiments echoed in the comments thread from Scobles recent "How to hate Microsoft" post. As indicated in my response to this post, I don't believe Microsoft is as bad or evil as is instinctively assumed in many quarters, but I can certainly understand why they are hated by others which is really unfortunate, especially bearing in mind that they have done more good than harm to date (in my humble opinion) .
Anyway, back to my concerns post PDC which I break down as follows:
WinFS needs to architecturally separate the System Provider from the Data Provider (pretty much the OLE-DB architecture) with Microsoft naturally providing reference System Provider (pretty much what was demonstrated at PDC) and Data Provider (ADO.NET, OLE DB, and ODBC) implementations. Third parties can choose to produce custom WinFS Service or Data Providers which serve their data access needs. It's impractical to want to force every non SQL Server customer over to SQL Server in order them to exploit WinFS, and I certainly hope this isn't the definitive strategy at Microsoft.
]]>NETWORK WORLD NEWSLETTER: MARK GIBBS ON WEB APPLICATIONS
Today's focus: A Virtuoso of a server
By Mark Gibbs
One of the bigger drags of Web applications development is that building a system of even modest complexity is a lot like herding cats - you need a database, an applications server, an XML engine, etc., etc. And as they all come from different vendors you are faced with solving the constellation of integration issues that inevitably arise.
If you are lucky, your integration results in a smoothly functioning system. If not, you have a lot of spare parts flying in loose formation with the risk of a crash and burn at any moment.
An alternative is to look for all of these features and services in a single package but you'll find few choices in this arena.
One that is available and looks very promising is OpenLink's Virtuoso (see links below).
Virtuoso is described as a cross platform (runs on Windows, all Unix flavors, Linux, and Mac OS X) universal server that provides databases, XML services, a Web application server and supporting services all in a single package.
OpenLink's list of supported standards is impressive and includes .Net, Mono, J2EE, XML Web Services (Simple Object Application Protocol, Web Services Description Language, WS-Security, Universal Description, Discovery and Integration), XML, XPath, XQuery, XSL-T, WebDav, HTTP, SMTP, LDAP, POP3, SQL-92, ODBC, JDBC and OLE-DB.
Virtuoso provides an HTTP-compliant Web Server; native XML document creation, storage and management; a Web services platform for creation, hosting and consumption of Web services; content replication and synchronization services; free text index server, mail delivery and storage and an NNTP server.
Another interesting feature is that with Virtuoso you can create Web services from existing SQL Stored Procedures, Java classes,
C++ classes, and 'C' functions as well as create dynamic XML
documents from ODBC and JDBC data sources.
This is an enormous product and implies a serious commitment on the part of adopters due to its scope and range of services.
]]>Virtuoso is enormous by virtue of its architectural ambitions, but actual disk requirements are
Strangely enough, when there is a reference to my blog the urls are broken because they actually point to articles from my internal blog (which is part of a private net behind a firewall). Now, I do actually blog behind my corporate or home firewall (depending on my location at time of blogging), and I when I blog the actual typing and editing occurs within a single Blog Editor (typically using Zempt, w.bloggar, or Newzcrawler). My blog posts are propagated (conditionally using upstream rules via the Virtuoso Blog Engine) to many surrogate blogs such as the ones listed above which may or may not be Virtuoso based, they just need to support Blog Post APIs such as Moveable Type, Meta-Weblog, or Blogger.
Anyway, I need to know if there is something about this blog site that is tripping up Feedster.
]]>October the 1st is an emotional day for many Nigerians, especially those of us in the Diaspora. Our country remains a paradox as the excerpts below attest:
The more popular view of Nigerians as a result of the proliferation of 419 scams (the mangled by-product of misdirected intellectual prowess and the boundless depths of greed -- which applies to perpetrators and victims alike).
The Nigerian SCO Connection "I AM MR. DARL MCBRIDE CURRENTLY SERVING AS THE PRESIDENT AND CHIEF EXECUTIVE OFFICER OF THE SCO GROUP ..." [via Be Blogging]
Funny! But many a truth is told in jest (I think that's how the quote goes); this one is pretty damned poignant.
Unbeknownst to many, there are other views of Nigeria (unfortunately these aren't the norm).
The call for optimism by our president (he doesn't support or condone the 419 nonsense):
Â
President Olusegun Obasanjo urged Nigerians to change their ways and be optimistic about the future as
[via Odili.net � this site desperately needs RSS!]
Â
There is an increasing pool of key high-tech players of Nigerian decent (and nationality)Â making constructive impact on the high-tech industry (making it less lonely for myself and other Nigerians in the high-tech arena):
Â
Dare Obasanjo is a member of Microsoft's WebData team, which among other things develops the components within the System.Xml and System.Data namespace of the .NET Framework, Microsoft XML Core Services (MSXML), and Microsoft Data Access Components (MDAC). More of Dare's writings on XML can be found on his Extreme XML column on MSDN.
Â
Uche Ogbuji is a consultant and co-founder of Fourthought Inc., a consulting firm specializing in XML solutions for enterprise knowledge management applications. Fourthought develops 4Suite, the open source platform for XML middleware. Mr. Ogbuji is a Computer Engineer and writer born in
Website:Â http://www.fourthought.com/
Â
Philip Emeagwali, a computer scientist, is one of the fathers of the Internet and a trailblazer in petroleum extraction," as quoted by CNN.Â
Â
Philip leaves all Nigerians with this important message on this special day (key excerpt below):
"Our investments in education and technology will be our legacy to our children. They are investments that will bring the best out of the next generation of Nigerians and enable us to reach our potential as individuals, as communities, as a nation."
Happy Birthday dear motherland!
AfricaNigeriaxml]]>With statement above in mind it's quite pleasing to see the emerging pool of .NET bridges for the Java Virtual Machine (basically tools that allow the use of Java Components within the .NET CLI (CLR and .NET bound languages e.g. C#, VB.NET, and others):
JavaBridge (awaiting url)
]]>Back to the article. This is an essay by George Gregorio who is so into auto discovery that he deliberately stuffed his contact details in an FOAF file that you need to auto discover using a FOAF auto discovery aware client (e.g. FOAFnaut or the human brain for instance :-) ) . Anyway, he is an excerpt from his essay (a very good read).
Over a month ago Paul Ford published a great essay entitled How Google beat Amazon and Ebay to the Semantic Web. After reading it the first time I thought it was a great introduction to the Semantic Web, an idea I had been trying to wrap my head around even since encountering RDF as it is baked into RSS 1.0. I had seen the light and bought into the promise of the Semantic Web.
Time passes...
With Dave Winer's floating of the idea of RSS 2.0 discussions ensue about the RDF in RSS 1.0. After spending some time badgering poor Bill Kearney for a concrete benefit of having RDF in RSS 1.0 and not getting a really satisfactory answer I went back and read Paul Ford's essay again. I wanted to get that old religious feeling back again. It didn't work. The magic was gone.
]]>
Howl is Rendezvous for Windows and Linux. [via Scripting News]
In the case of UDA you can configure ODBC and JDBC consumable data source names that are hosted on the server. Users can nownbspsimply picknbspDSNs from anbspcombo box and they are ready to make connections to remote databases from any ODBC, JDBC, OLE DB, or ADO.NET application.nbspAnother benefit ofnbspZeroconfignbspis that it facilitates centralized server side configuration which further enhances our server side session rules book;nbspwhich serves all our Multi-Tier data access drivers.
In the case of Virtuoso you are able to bind to pre-configured Virtuoso instances in exactly the same way.
Our Zeroconfig support has beennbspimplemented across Solaris, AIX, Digital UNIX, IRIX, HP-UX amongst others, but this is a project of interest all the same, and we may end up contributing to this effort.
]]>[via The Scobleizer Weblog]
Now this is good news from Microsoft! This means that products like Virtuoso can now compete head-on with Yukon (on a level playing field when it arrives) as far as Visual Studio.NET integration goes. Hopefully I will no longer have to rant about any of the following:
I wonder if the same degree of openness could extend to Web Matrix? That would be something indeed!
]]>"A Manager's Guide," as the title suggests, is the perfect pragmatic guide for managing a current web-services project. If you want to know what works today, right down to the specific products from individual vendors, Anne's book is the one to buy. .NET versus Java? Which J2EE platform or UDDI registry server? The current state of the basic protocols: SOAP, WSDL, UDDI? You'll find the answers in one place. As with my book, there are no code fragments or XML listings. It's for managers, not programmers. But this book is the one to buy for your tactical requirements.
"Loosely Coupled," on the other hand, takes a more strategic view, and in a sense picks up where Anne's book leaves off. I don't explain any of the protocols. In fact I rarely mention them by name. I assume (a) you'll learn about them somewhere else (such as from Anne's book), and (b) they'll change quickly anyway. Anne has a 30-page chapter on "Advanced Web-Services Standards," which is where my book kicks in. As the subtitle suggests, I look more deeply at the missing pieces of web services: transactions, security, reliable asynchronous messaging, orchestration and choreography, QoS, contracts and other business issues, infrastructure, and the big one: industry-specific semantics.
Both books cover the fundamental concepts of web services such as service-oriented architectures. Anne, however, sees web services as being fundamentally about application integration, which clearly is the sweet spot today. I look at the issues surrounding inter-organizational loosely coupled web services, taking a longer-term and more strategic view. If you're thrust into managing a web-services project, need to ramp-up quickly, select vendors and products, and be able to communicate with your developers, buy Anne's book. If you need to develop a long-term web-services strategy for your organization, buy mine. In other words: buy them both. I think you'll like the combination.
]]>Certinaly an interesting proposition, or should I say vision, but I don't think this proposition does justice to some of the valid insights contained in this recent IDG interview with Tim O'Reilly. Here are some of Tim's quotes:
"Nobody is pointing out something that I think is way more significant: all of the killer apps of the Internet era: Amazon (.com, Inc), Google (Inc.), and Maps.yahoo.com. They run on Linux or FreeBSD, but they're not apps in the way that people have traditionally thought of applications, so they just don't get considered. Amazon is built with Perl on top of Linux. It's basically a bunch of open source hackers, but they're working for a company that's as fiercely proprietary as any proprietary software company."
Solutions are always more important that the technology that makes up the solutions from a business development perspective. The trouble is that the constituent parts of a solution ultimately affect the longevity of the solution (the future adaptability of the solution), hence the middleware and components segments of the software industry.
"With eBay it's even clearer. The fact is, it's the critical mass of marketplace buyers and sellers and all the information that people have put in that marketplace as a repository."
"So I think we're going to find more and more places where that happens, where somebody gets a critical mass of customers and data and that becomes their source of value. On that basis, I will predict that -- this is an outrageous prediction -- but eBay will buy Oracle someday. The value will have moved so much to people who are not now seen as software suppliers."
In reading this article that I can only assume that Tim does realize the inevitable; computing is, and always will be about data -- creation, transformation, dissemination, and exploitation. That said, you don't maximize the opportunities that such a realization accords by acquiring the largest vendor of database software.
The largest database vendor doesn't imply dominance in any of the following areas:
I see the Internet as the Database (comprising various forms), and the Web as a dominant database segment within Internet realm. Every Internet Point of Presence is really a point of Data interaction; Creation, Storage, Access, Dissemination, and Exploitation.
eBay can acquire a license from Oracle or any other database vendor and still be sucessful, and all they need to do is come to the actual realization that like Amazon and Google they could become a very important Executable and Semantic Web platform by finally understanding that their home page isn't that important, it's the interactions with the site that matter. All of this is certainly achievable without acquiring Oracle.
In short, this applies to any organization that seeks to incorporate the Internet into their operational strategy (Business Development, Customer Services, Intranets, Extranets etc.). I am inclined to believe that Sofware Commoditization (which has been with us for a very long time) is the new moniker for "its all about data" or to quote Sam Ruby, "It's just data".
]]>Tim O'Reilly wrote some thoughts about network aware software. Good sumup and nice ideas, why not only blogs should be net-aware (and where even blogs can be improved ;) )
"For the desktop, my personal vision is to see existing software instrumented to become increasingly web aware. It seems that Apple are doing a good job with this. (What does web aware mean for me? Being able to grok URIs, speaking WebDAV, and using open standard data formats.)" -- Edd Dumbill[via Bitflux Blog]
Rendezvous-like functionality for automatic discovery of and potential synchronization with other instances of the application on other computers. Apple is showing the power of this idea with iChat and iTunes, but it really could be applied in so many other places. For example, if every PIM supported this functionality, we could have the equivalent of "phonester" where you could automatically ask peers for contact information. Of course, that leads to guideline 2.
Another application is discovery of ODBC data sources, and database servers. Rendezvous can also simply security and administration of data sources accessible by either one of these standards data access mechanisms. It can also apply to XML databases and data sources exposed by XML Databases.
The very point I continue to make about Internet Points of Presence beingactual data acces points, in short these end points should be served by database serverprocesses. This is the very basis of Virtuoso, the inevitability of this realization remains the undepinings of this product. There are other products out there that have some sense of this vision too, but there is a little snag (at least so far in my research efforts), and that is the tendency to create dedicated independent server per protocol (an ultimate integration, administration, and maintenance nightmare).
The performance issues arenbspnow long forgotten (at least as far as OpenLink Software's contribution to ODBC goes). But the ODBC Drivers must be FREE as they offer little or no value problem rages on.
The Usenet posting below pretty much sums up why I decided that OpenLink needednbspto get into the ODBC Driver business in the first place. We anticipated significant problems in the area of usability, configurability and security if all a driver had to offer was query fulfillment in the form of a result set.
The excerpt below shows an all too common dilemma with ODBC (should you reach rollout and put ODBC in the hands of information and knowledge workers):
nbspHi all,
I set up an Excel spreadsheet to our production database through ODBC driver to get a report. Everything was working fine, and life was good until I found a little problem with the SQL tool in Excel.
Normally, to get a report Excel will write a select statement according to criterias that the users input/ choose. It also allows anyone to Edit the select statement it writes in a little box. What I did was changing that select statement to delete/update statement. And it ran.
What surprised me was that it actually ran the statement against the database and delete/update tables accordingly. This is not what we want. I have not been able to find any options to turn this thing off so that the user cannot edit the generated select SQL.
I know all the permissions the user has are defined through the username that is defined in ODBC. We don't want to change all the user permissions on the database side. Is there any other way ? MS Excel 2000 Informix IDS 9.30 UC1 Dynix/ptx V4.5.3 Thanks N.
The user's ODBC usage requirements are unconventional to a database engine. What do I mean? Well relational databases fundamentally handle security on a user or role basis, and this security schemes can be applied to tables and rows, but it does nothing for this scenario.
The ODBC Drivers from OpenLink Software were built (in 1993 I might add)nbspwith thisnbspmiddleware predicamentnbspand more in mind. As you might imagine, most ODBC vendors will tell you to sort out the security either at thenbspdatabase end or the client application end.nbsp
OurnbspDrivers (the Multi-Tier variant) on the other hand enable you to configure a set of rules that will enforce read-only access on an application basis such that in this particular case when Excel is used the session is read-only irrespective of what exits MS Query. The rules can even enable read-write or read-only access to Excel (or other ODBC compliant application) and the basis of any combination of the following: username, client ip, machine alias, application, lan subnet, and any user definable profile (we call these domains).
Additional reading as this is only the tip of the iceberg.
]]>Under normal circumstances this would be a very scary propositon - weblogs have reached hype status, and this means 800 pound gorillas are approaching the patch!. Why should we create our own blogsphere FUD.
Well things work differently in the blogspehere, and it leads to wonderful opportunities for like minded individuals to put their vast array of skills to constructive use. My hunch is that this effort -syndication format standardization- will be sorted out quickly, and even act as a showcase for the collaborative prowess of Blogs and Wikis. Take a look at the blog snippet below (I urge you to follow the Wiki link).
Sam Ruby is leading an effort to create a new weblog format and API. There's a Wiki that's open for all to contribute to, and an impressive list of people who support the work. [via Scripting News]
I hope this is one of many similar efforts that usher in the next phase of the Web (the Semantic one of course!).
]]>
... that between MS and open source initiatives, there will be no room in the marketplace for small software companies.
This is an interesting article, one that brings up many good points. Overall, I don't really agree with him. I think, for the most part, commercial software companies will still be able to co-exist with MS and open source in the market place.
Open source software is great, and I think its a great resource of applications for technologically savvy people (especially developers), but it's still not targeted at novice end users (like my mom). Will this change in the future? Probably to some extent, but I still think open source will lag behind commercial software vendors due to lack of marketing and polishing.
On the other hand, I do see a specific niche of the software development market dieing out in the next few years due to the open source movement: custom control vendors. These guys have been lucky for the past decade because most development shops don't want to spend the time writing the next cool button bar, but many developers on their own time love this kind of development. Just look at Code Project. Anytime we need a control for one of our apps, Code Project is the first place we go. Why? Well, not only do we get great controls, we get the source! This way, if something is screwed up (which is has been), we can fix the bug and move on (which we do [and send it to the control developer]).
BTW, if anyone thinks that a small development shop can't exist when competing against the likes of MS and open source, check out fog creek software. Joel has managed to create a profitable software company, that sells a few great products, make a little bit of money and provide his developers offices.
One day maybe I'll be fortunate enough to work for Joel!
[via WebLogs @ ASP.NET]
Easy Data UI Generation. Web Matrix makes it easy to create data bound pages without writing code. Drop SQL/MSDE or Access tables on your page to create data-bound grids, or start with Data Page templates for reports or Master/Detail pages. Code builders help you generate code to select, insert, update and delete SQL/MSDE or Access data.
[via WebLogs @ ASP.NET]
The next release of SQL Server promises increased developer productivity and reduced DBA workload.
by Roger Jennings June 2003 Issue .NET Magazine
After reading this article I decided to put together a simple comparitive analysis of our existing product and the soon to be released Yukon.
Our Universal Server product called Virtuoso will compete head on with this future release of SQL Server in many regards (.NET CLR hosting, Native XML Types, SQL-XML, XMLA, Web Services etc.), but I am also keen to see what interesting perspectives Microsoft's implementation brings to the table. Here is a summary comparison, note that some of the hyperlinks in the table below actually take you to live functionality demos (for effect these links point to a Linux server, and you can change the machine part of the url from "demo" to "kingsleydemo" to see the equivalent demos on an XP server).
Ingres (technically, Advantage Ingres Enterprise) is, arguably, the forgotten database. There used to be five major databases: Oracle, DB2, Sybase, Informix and Ingres. Then along came Microsoft and, if you listened to most press comment (or the lack of it), you would think that there were only two of these left, plus SQL Server. [From IT-Director]
]]>Oracle, Microsoft, and IBM would certainly like the illusion of a 3 horse race, as this is the only way they can induce Ingres, Informix, and Sybase users to jump ship, and this, even though database migrations are by far the most risk prone and problematic aspects of any IT infrastructure.
Here is the interesting logic from the self-made big three, if you want to take advanatage of new paradigms and technologies such as XML, Web Services, and anything else in the pipeline you have to move all your data out of these databases, and then get all the mission critical applications re-associated with one of these databases, and by the way when you do so it is advisable that you use native interfaces (so that sometime in the future you have no chance whatsoever of repeating this folly at their expense).
The simple fact of the matter (which the self-made big three do not want you to know) is that you can put ODBC, JDBC, even platform specific data access APIs such as OLE DB and ADO.NET atop any of these databases, and then explore and exploit the benefits of new technologies and paradigms as long as the tool pool supports one of more of these standards.
Unfortunately the no-brainer above appears to be the more difficult of the choices before decision makers. In other words, many would rather dig themselves into a deeper hole (unknowingly i can only presume) that ultimately leads to technology lock-in.
The biggest challenge before any RDBMS based infrastructure today isn't which of the self-made big three to migrate to wholesale, rather, how to make progressive use of the pool of disparate applications, and application databases that proliferate the enterprise.
This is another way of understanding the burgeoning market for Virtual Databases, which in my opiion present the new frontier in database technology.
There is a good article in CodeProject about the Entity Design Pattern. The guy who wrote it is definitely in the same frequency as DeKlarit.
[via Andres Aguiar's Weblog]
]]>[From Frans Bouma's blog in Boldface, My comments in italics]
Randy Holloway wrote about his vision on Linux and then especially about Linux on the desktop. I disagree with his vision, I think Linux is definitely an option for the desktop at the moment and thus also in the foreseably future. It will become the option for the desktop when Mono is completed. The reason for this is simple: a lot of Windows programs will be written using .NET. If you can run these programs on Linux too, using Mono, what's keeping you on Windows? Perhaps the games. But definitely not the business applications, since the Linux version for spreadsheets, browsers, wordprocessors, emailprograms and other every-day software are solid today, even when compared to Microsoft Office XP.
Linux desktop office applications do not rival those of Windows, in particular Office 2003. We have to be careful when we make generic statements such as this becuase the end result is disappointment and frustation for corporate Linux neophyte.
Imagine a corporate power user that has used Excel to produce Pivot tables (like I do) that provide me with a critical success factors dashboard for my enterprise. If I was to move to any of the incarnations of open office this would be lost. Now, for the corporate user -knowledge, information worker- that I believe Randy has in mind this remains a problem re. Linux as a desktop offering today.
On the other hand, how true is the position that I presented above? By this I mean, how many knowledge workers actually make use of Pivot Tables in Excel? Something tells me I am the exception rather than the norm. Thus, moving away from Desktop productivity tools of type "Office 200x", and looking at email, and web browsing etc. Linux certainly matches Windows pound for pound, but is this enough? What is the current "activation threshold" for Windows vs. Linux for a Desktop user (who just wants email and web browsing)? I think this is Linux distribution dependent, now the last time I attempted this experiment (at least over a year ago) Windows won flat out becuase I had to wrestle with X Configuration en route to getting a graphical desktop (I believe this has improved vastly of late, but I need to perform this experiment using current 8.x and higher Linux distros.).
I've hated Linux and especially its most hardcore supporters, for years. However, you can't have an unbiased vision on what is best for a given company to use as the OS of choice if you are biased yourself. Mono changed me, I really think Mono is the best Linux has ever experienced: it makes transitions of software written for the Windows platform to a free (as in beer, I don't believe in the GPL-philosophy) OS possible.
Mono is going to be the most significant Linux <--> Windows harmonization effort over the long term. This is because parity will no longer be about getting the likes of Open Office to reach functional parity with "Office 200x" as future Windows applications will be "managed code" in nature (a strategic Microsoft goal over the long term), and Mono's goal is to run "managed code" outside the Windows platform (this applies to Linux, UNIX, and other platforms).
Besides Mono, I do think Linux is a good platform to use for everyday business applications today, because the office tools can use Exchange, they can read/write MS Office documents, so why bother investing in MS software when you can save that money and choose the alternative? The only problem is: when you have a lot of desktops to admin as a sysadmin, and you want to do that with the easy tools in Windows server 2003, you're out of luck.
Linux is a good platform for everday business applications, but not quite good enough in the area of unravelling it's value proposition to the point of obvious simplification for corporate decision makers. This is the current hump in the road to this critical destination in my humble opinion.
Randy and Frans are making very good points that shed light on some of the less covered aspects of the Linux vs. Windows debate.
]]>[From Frans Bouma's blog in Boldface, My comments in italics]
Randy Holloway wrote about his vision on Linux and then especially about Linux on the desktop. I disagree with his vision, I think Linux is definitely an option for the desktop at the moment and thus also in the foreseably future. It will become the option for the desktop when Mono is completed. The reason for this is simple: a lot of Windows programs will be written using .NET. If you can run these programs on Linux too, using Mono, what's keeping you on Windows? Perhaps the games. But definitely not the business applications, since the Linux version for spreadsheets, browsers, wordprocessors, emailprograms and other every-day software are solid today, even when compared to Microsoft Office XP.
Linux desktop office applications do not rival those of Windows, in particular Office 2003. We have to be careful when we make generic statements such as this becuase the end result is disappointment and frustation for corporate Linux neophyte.
Imagine a corporate power user that has used Excel to produce Pivot tables (like I do) that provide me with a critical success factors dashboard for my enterprise. If I was to move to any of the incarnations of open office this would be lost. Now, for the corporate user -knowledge, information worker- that I believe Randy has in mind this remains a problem re. Linux as a desktop offering today.
On the other hand, how true is the position that I presented above? By this I mean, how many knowledge workers actually make use of Pivot Tables in Excel? Something tells me I am the exception rather than the norm. Thus, moving away from Desktop productivity tools of type "Office 200x", and looking at email, and web browsing etc. Linux certainly matches Windows pound for pound, but is this enough? What is the current "activation threshold" for Windows vs. Linux for a Desktop user (who just wants email and web browsing)? I think this is Linux distribution dependent, now the last time I attempted this experiment (at least over a year ago) Windows won flat out becuase I had to wrestle with X Configuration en route to getting a graphical desktop (I believe this has improved vastly of late, but I need to perform this experiment using current 8.x and higher Linux distros.).
I've hated Linux and especially its most hardcore supporters, for years. However, you can't have an unbiased vision on what is best for a given company to use as the OS of choice if you are biased yourself. Mono changed me, I really think Mono is the best Linux has ever experienced: it makes transitions of software written for the Windows platform to a free (as in beer, I don't believe in the GPL-philosophy) OS possible.
Mono is going to be the most significant Linux <--> Windows harmonization effort over the long term. This is because parity will no longer be about getting the likes of Open Office to reach functional parity with "Office 200x" as future Windows applications will be "managed code" in nature (a strategic Microsoft goal over the long term), and Mono's goal is to run "managed code" outside the Windows platform (this applies to Linux, UNIX, and other platforms).
Besides Mono, I do think Linux is a good platform to use for everyday business applications today, because the office tools can use Exchange, they can read/write MS Office documents, so why bother investing in MS software when you can save that money and choose the alternative? The only problem is: when you have a lot of desktops to admin as a sysadmin, and you want to do that with the easy tools in Windows server 2003, you're out of luck.
Linux is a good platform for everday business applications, but not quite good enough in the area of unravelling it's value proposition to the point of obvious simplification for corporate decision makers. This is the current hump in the road to this critical destination in my humble opinion.
Randy and Frans are making very good points that shed light on some of the less covered aspects of the Linux vs. Windows debate.
]]>In case you missed it, A.N.Other added a comment to my recent post on Mozilla Firebird, succintly pointing to a project which is building .NET wrappers for the Gecko engine using Managed C++. I've not yet had a chance to look into this any further. [via Cook Computing] [via Andres Aguiar's Weblog]
This is an interesting development, the crux of the matter being accessibility to Gecko from Visual Studio. Details
In case you missed it, A.N.Other added a comment to my recent post on Mozilla Firebird, succintly pointing to a project which is building .NET wrappers for the Gecko engine using Managed C++. I've not yet had a chance to look into this any further. [via Cook Computing] [via Andres Aguiar's Weblog]
This is an interesting development, the crux of the matter being accessibility to Gecko from Visual Studio. Details
Borland, Microsoft Move Closer on Databases The two competitors put differences aside to push a new environment on the .NET Framework. [via Internet Product News]
Ah! Now I get it, let's be database specific by bundling developer copies of all the supported databases. So we get one really huge product simply becuase we don't realize that ADO.NET pretty much ensures some degree of DB independence (ODBC delivers the real thing for SQL. but that's old hat! Not!).
Ah! Now I get it, let's be database specific by bundling developer copies of all the supported databases. So we get one really huge product simply becuase we don't realize that ADO.NET pretty much ensure some degree of DB independence (ODBC delivers the real thing for SQL. but that's old hat! Not).
]]>
Last night we updated the ASP.NET Website
]]>Last night we updated the ASP.NET Website to ASP.NET 1.1. So far so good, we found a couple of bugs in the forums that we had to patch this morning, but overall the site seems to run faster! Today we got even more good news, we should have our new dual-processor SQL box online by-end-of-week. It's somewhat amazing that our little SQL Server (single-proc. 750 MHZ 1GB RAM) has handled the load of (we're serving about 100K unique users / day on the site right now.):
Unfortunately the search functionality of the forums is killing CPU utilization on the SQL Server. Once we get the new DB in place we'll dedicate it to the forums --- should definitley speed up the site even more! [via Rob Howard's Blog]
]]>Not strange at all, that's how Monopolies operate. They do not have any embracing to do right now (in other words there is nothing to kill in this market place).
I have over 150 weblogs I monitor through my new reader and a good portion of them are MS employees (becuase I work in a MS enviroment). To the best of my knowledge, not one of them is from the IE team. All this has lead me to ask if IE is dead. If so, is it because MS doesn't see any point in developing it further or could they be worried that any further development would be viewed as anti-competitive?
The problem here is no direction, many of the larger companies live of the innovation of smaller companies. The like to say, "Ah"! "We'll have one of those in the future sometime...", and then crush smaller company if the FUD (Fear Uncertainty Doubt) doesn't bury the perceived threat (anything that is generating revenue that they aren't taxing; bottom-line).
Well while the cat's away the mice will play, Mozilla is getting stronger and better by the minute. So there may just be a reason for IE to come back to its destructive life.
[via Slightly Bent]
]]>
Not strange at all, that's how Monopolies operate. They do not have any embracing to do right now (in other words there is nothing to kill in this market place).
I have over 150 weblogs I monitor through my new reader and a good portion of them are MS employees (becuase I work in a MS enviroment). To the best of my knowledge, not one of them is from the IE team. All this has lead me to ask if IE is dead. If so, is it because MS doesn't see any point in developing it further or could they be worried that any further development would be viewed as anti-competitive?
The problem here is no direction, many of the larger companies live of the innovation of smaller companies. The like to say, "Ah"! "We'll have one of those in the future sometime...", and then crush smaller company if the FUD (Fear Uncertainty Doubt) doesn't bury the perceived threat (anything that is generating revenue that they aren't taxing; bottom-line).
Well while the cat's away the mice will play, Mozilla is getting stronger and better by the minute. So there may just be a reason for IE to come back to its destructive life.
[via Slightly Bent]
]]>
A few days ago, I was waiting at a dentist and trying to kill the time thought of using my Nokia 3650 (with Doris HTML browser) to have a look at your site, to see if there's anything there that might put my mind on other matters than the precarious closeness of the dentist drilling machines! And what I found out was how hard it was to get to the actual content on your site...I had to scroll through all of what is usually hidden...after about 10 minutes or so I finally got to the content. Any way to redesign it, so that content gets loaded first or putting up a mobile lightweight version?
Excellent point. I thought about this for five seconds and realized that Rob could solve this problem for himself -- and for others -- in a very simple way. I pointed him at the solution, and he picked up the ball and ran with it. ...
My blog is currently available in two XML flavors: the standard feed and the extended feed. My suggestion to Rob was to write an XSLT transform for one or the other, and pipe the XML content through it (using the W3C's public XSLT transformation service) to create a lightweight HTML rendering.
Here is the XSLT file Rob wrote. Here's how it renders my standard feed. Here's how it renders my extended feed.
As Rob notes in his writeup, there was a problem with the extended feed, so originally he was only able to pipe the standard feed to his Nokia. But that was my fault, not his. I kicked my setup and it seems to be working properly now. Rob's conclusion:
Wow, that was pretty simple and quite powerful. The power of this kind of ad hoc scripting never ceases to amaze me! [Clarity's Blog]
[via Jon's Radio]
Very cool! The power of XSLT! Now I am sure we can see how Virtuoso would extend this further? In short I will try to have this become an attribute of my Blog.
Virtuoso could enable this site to automatically determine what type of User Agent (clients such as Web Browsers)
]]>A few days ago, I was waiting at a dentist and trying to kill the time thought of using my Nokia 3650 (with Doris HTML browser) to have a look at your site, to see if there's anything there that might put my mind on other matters than the precarious closeness of the dentist drilling machines! And what I found out was how hard it was to get to the actual content on your site...I had to scroll through all of what is usually hidden...after about 10 minutes or so I finally got to the content. Any way to redesign it, so that content gets loaded first or putting up a mobile lightweight version?
Excellent point. I thought about this for five seconds and realized that Rob could solve this problem for himself -- and for others -- in a very simple way. I pointed him at the solution, and he picked up the ball and ran with it. ...
My blog is currently available in two XML flavors: the standard feed and the extended feed. My suggestion to Rob was to write an XSLT transform for one or the other, and pipe the XML content through it (using the W3C's public XSLT transformation service) to create a lightweight HTML rendering.
Here is the XSLT file Rob wrote. Here's how it renders my standard feed. Here's how it renders my extended feed.
As Rob notes in his writeup, there was a problem with the extended feed, so originally he was only able to pipe the standard feed to his Nokia. But that was my fault, not his. I kicked my setup and it seems to be working properly now. Rob's conclusion:
Wow, that was pretty simple and quite powerful. The power of this kind of ad hoc scripting never ceases to amaze me! [Clarity's Blog]
[via Jon's Radio]
Very cool! The power of XSLT! Now I am sure we can see how Virtuoso would extend this further? In short I will try to have this become an attribute of my Blog.
Virtuoso could enable this site to automatically determine what type of User Agent (clients such as Web Browsers) is being used by the visitor and then automatically associated the required XSTL stylesheet for the User Agent.
This was one of the very basic Virtuoso XML and XSLT demos (circa 2000-2001).
Blogging is going to provide a very fluid demo canvas for Virtuoso as this article demonstrates.
]]>
 http://www.sqlsecurity.com/DesktopDefault.aspx?tabindex=2&;tabid=3
Are other SQL Servers (Sybase, Oracle, DB2) subject to SQL injection? Yes, to varying degrees. Here is a site that can get you more details on some of the issues with other SQL Servers. http://www.owasp.org What is SQL Injection and why is all this information not included in the regular FAQ?SQL Injection is simply a term describing the act of passing SQL code into an application that was not intended by the developer.  Since this topic is not specifically restricted to SQL Server it is not included in the normal FAQ. In fact, much of the problems that allow SQL injection are not the fault of the database server per-se but rather are due to poor input validation and coding at other code layers. However, due to the serious nature and prevalence of this problem I feel its inclusion in a thorough discussion of SQL Server security is warranted. What causes SQL Injection? SQL injection is usually caused by developers who use "string-building" techniques in order to execute SQL code. For example, in a search page, the developer may use the following code to execute a query (VBScript/ASP sample shown): Set myRecordset = myConnection.execute("SELECT * FROM myTable WHERE someText ='" & request.form("inputdata") & "'") The reason this statement is likely to introduce an SQL injection problem is that the developer has made a classic mistake - poor input validation. We are trusting that user has not entered something malicious - something like the innocent looking single quote ('). Let's consider what would happen if a user entered the following text into the search form: ' exec master..xp_cmdshell 'net user test testpass /ADD' -- Then, when the query string is assembled and sent to SQL Server, the server will process the following code: SELECT * FROM myTable WHERE someText ='' exec master..xp_cmdshell 'net user test testpass /ADD'--' Notice, the first single quote entered by the user closed the string and SQL Server eagerly executes the next SQL statements in the batch including a command to add a new user to the local accounts database. If this application were running as 'sa' and the MSSQLSERVER service is running with sufficient privileges we would now have an account with which to access this machine. Also note the use of the comment operator (--) to force the SQL Server to ignore the trailing quote placed by the developer's code. Very intresting that these are all Native Interface based exploits. So the security issue isn't ODBC, JDBC, ADO.NET, or OLE DB specific (although they certainly increase the potential damage that can be unleashed via metadata analysis en route to that huge Cartesian Product ; the mother of all Exploits!). Our Session Rules Book was devised in 1993 with many of these issues in mind, and to this date there are no other ODBC/JDBC/OLE DB products out there that even come close to acknowledging this reality. |
http://www.sqlsecurity.com/DesktopDefault.aspx?tabindex=2&;tabid=3
Are other SQL Servers (Sybase, Oracle, DB2) subject to SQL injection? Yes, to varying degrees. Here is a site that can get you more details on some of the issues with other SQL Servers. http://www.owasp.org What is SQL Injection and why is all this information not included in the regular FAQ?SQL Injection is simply a term describing the act of passing SQL code into an application that was not intended by the developer. Since this topic is not specifically restricted to SQL Server it is not included in the normal FAQ. In fact, much of the problems that allow SQL injection are not the fault of the database server per-se but rather are due to poor input validation and coding at other code layers. However, due to the serious nature and prevalence of this problem I feel its inclusion in a thorough discussion of SQL Server security is warranted. What causes SQL Injection? SQL injection is usually caused by developers who use "string-building" techniques in order to execute SQL code. For example, in a search page, the developer may use the following code to execute a query (VBScript/ASP sample shown): Set myRecordset = myConnection.execute("SELECT * FROM myTable WHERE someText ='" & request.form("inputdata") & "'") The reason this statement is likely to introduce an SQL injection problem is that the developer has made a classic mistake - poor input validation. We are trusting that user has not entered something malicious - something like the innocent looking single quote ('). Let's consider what would happen if a user entered the following text into the search form: ' exec master..xp_cmdshell 'net user test testpass /ADD' -- Then, when the query string is assembled and sent to SQL Server, the server will process the following code: SELECT * FROM myTable WHERE someText ='' exec master..xp_cmdshell 'net user test testpass /ADD'--' Notice, the first single quote entered by the user closed the string and SQL Server eagerly executes the next SQL statements in the batch including a command to add a new user to the local accounts database. If this application were running as 'sa' and the MSSQLSERVER service is running with sufficient privileges we would now have an account with which to access this machine. Also note the use of the comment operator (--) to force the SQL Server to ignore the trailing quote placed by the developer's code. Very intresting that these are all Native Interface based exploits. So the security issue isn't ODBC, JDBC, ADO.NET, or OLE DB specific (although they certainly increase the potential damage that can be unleashed via metadata analysis en route to that huge Cartesian Product ; the mother of all Exploits!). Our Session Rules Book was devised in 1993 with many of these issues in mind, and to this date there are no other ODBC/JDBC/OLE DB products out there that even come close to acknowledging this reality. |
Here?s what this three-part series will cover:
My Comments:
I am a firm believer in the possibilities presented by XUL. It will enable the bundling of UI, Data, Data Manipulation logic (Application or Module ) as part of a payload hosted on report server Like Virtuoso. Basically, I anticipate the emergence of an IDE that is able to persist is UI components (widgets) and UI behaviour as XML using the XUL grammer. Then along comes a XUL Processor that is able to emit a XUL based UI payloads ( via user agent aware transformation) as:
.NET/Mono Windows Forms assemblies
Javascript
Flash MX
XUL (If we know the client is Mozilla or Firebird for instance)
.....
I think this is a Virtuoso demo in the making :-)
]]>
More .NET languages are popping up everyday. I've put together one of the most extensive lists of languages and posted it here.
Its pulled from many sources including: .NET Languages (ASP.NET), Cetus, Language Vendors (MS GotDotNET), .NET Language Group (MS GotDotNET), Visual Studio Partners: Language Vendors (MS), Mono-list, Google, SourceForge.net
I'll try to keep this updated when I run across a new language. If anyone knows of any others, let me know.[via Brian Ritchie's Blog]
]]>More .NET languages are popping up everyday. I've put together one of the most extensive lists of languages and posted it here.
Its pulled from many sources including: .NET Languages (ASP.NET), Cetus, Language Vendors (MS GotDotNET), .NET Language Group (MS GotDotNET), Visual Studio Partners: Language Vendors (MS), Mono-list, Google, SourceForge.net
I'll try to keep this updated when I run across a new language. If anyone knows of any others, let me know.[via Brian Ritchie's Blog]
]]>I've installed and used both VMWare and Virtual PC on my tablet. VPC has one key advantage: It lets the guest OS use the right drivers for your hardware. VMWare installs its own drivers for things like display and network. In my case, VMWare's virtualized drivers caused two problems: The guest OS could not connect to the network using the host's wireless connection. This is meant I always had to be plugged in to an ethernet for the guest to be connected - an inconvenience more than a real problem. The second, more serious, issue was going into full screen. VMWare let me choose 640x480 or 1024x768. Going into full screen with the latter resolution caused my tablet's display to go into vertical (portrait) mode. I tried everything I could think of to put it back to landscape but had no success. This is a real issue since, needless to say, using VS .NET in 640x480 is a real challenge. VPC has none of these problems. I can use my wireless network from the guest OS and I can choose from 640x480, 800x600, and 1024x768 all in full screen mode. Although there's one slight problem in VPC: When using the wireless network, the guest OS cannot ping the host OS. I can live with that.
Next I want to install Longhorn in a VPC on my tablet. I don't even know if VPC supports Longhorn, stay tuned.[via Yasser Shohoud]
This is what blogs are supposed to be all about; unadulterated dissemination of knowledge. We have got to share knowledge as opposed to hoarding it!
]]>
For more see full article
]]>Net margins and return on equity are popular metrics that investors turn to in an effort to identify the most profitable companies. One less-used measure is return on invested capital, or ROIC.
Definitions of return on capital vary, but they all try to capture the same thing: how much a company has earned on all the capital it has invested, which includes both equity and debt. By including both, return on capital shows how a company uses all of its financial resources.
For our purposes, we define ROIC as earnings before interest, depreciation and amortization divided by invested capital. Invested capital encompasses shareholders' equity, plus all long-term liabilities and short-term debt.
WOW! We now use this metric to assess companies? Times have really changed!
This could be the basis of an XBRL project, the goal being to produce an XQuery to filter for all companies with a positive ROIC. Watch this space, it would be a great Virtuoso demo!
ROIC Industry Leaders | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Prices as of May 13 (with XBRL it would as of last XQuery). Sources would read: Would be my Virtuoso DB instance. |
]]>
It will come as a surprise to many that, with little fanfare, Microsoft officially entered the blogging-tool space. At the recent VSLive! developer conference, Microsoft unveiled five new sample applications built on top of its ASP.Net scripting environment. One of these five ? the ASP.Net Community Starter Kit ? is a blog builder.
The Community Starter Kit consists of application code, templates, documentation and forum-based help. According to Microsoft's own definition of the kit: "The Community Starter Kit enables you to quickly create a community Web site such as a user group site, a developer resource site, or a news site."
Some additonal commentary from Drupal:
Food for thought and discussion. What would happen when every MSN/Hotmail user was automatically given the option to opt in for a free weblog (a la LiveJournal)?
Here is an extreme scenario. Having single sign-on in place (.NET Passport), every MSN user could comment on anyone else's blog and have his personal preferences follow him or her as he/she travels from weblog to weblog; a problem the rest of the weblog world has yet to solve.
Well! I think we have one Virtuoso Blogging Subsystem evangelist in the making here :-)
Naturally, their weblogs would seemingly integrate with their IM service/client, and both Internet Explorer and Outlook would get a handy "blog this" feature. Moreover, having billions of MSN users, they could establish de facto technology standards and render existing technologies such as the Blogger API, MetaWeblog API and Trackback almost useless. At every aspect, they would have an immediate technical advantage over established weblog software.
Like you know what .. they would! These APIs simply need a product that demonstrates:
What they are, Why they are useful, and more importantly how they preserve freedom of choice re. IT infrastructure Lampooning -- (L)inux, (A)pache, (M)ySQL, (P)HP|ERL|YTHON|)-ONING -- isn't the solution but potentially the problem.
I think we see why OPS needs blogging, ditto Virtuoso !
]]>