test
Free OpenOffice.org 2.0 Suite Launches
By Gregg Keizer, TechWeb News An open-format group Thursday launched the final version of OpenOffice.org 2.0, a free application suite that's drawn attention from governments interested in breaking away from Microsoft's office application bundles.
OpenOffice.org 2.0, which has been in development for more than two years and recently delayed by some last-minute bugs, can now be downloaded from the Web in versions for Windows, Linux, and Solaris. A native Mac OS X edition is still being ported.
"OpenOffice.org is on a path toward being the most popular office suite the world has ever seen," claimed Jonathan Schwartz, the chief executive of Sun Microsystems, in a statement.
Sun and OpenOffice.org are linked by the code on which the suite is based. In 2000, Sun, which a year earlier had acquired a German company that developed StarOffice, released the code as the OpenOffice.org project. The two continue to share code, with Sun's StarOffice -- version 8 went final in late September -- sold commercially with bundled support.
Although Sun is the prime contributor to OpenOffice.org, others, including Novell, Red Hat, Debian, Propylon, and Intel, as well as a slew of independent programmers, pitched in to design, develop, test, and debug 2.0.
Recently, the suite has taken a more prominent place as some governments argue that documents must be based on open formats, not proprietary formats such as those used by Microsoft's Office, the bundle that has a near-monopoly on the office application market.
Massachusetts in particular has been a vigorous proponent of OpenOffice.org, and the OpenDocument format it subscribes to, and has rejected Microsoft's pitch of Office Open XML as a true open format.
OpenOffice.org also got a bit of a boost earlier this month when Sun and Google announced a long-range technology partnership. Although the pair have been short on specifics, speculation remains strong that StarOffice, or the open-format OpenOffice.org offshoot, might be the foundation for additional Google Web services in the future.
OpenOffice.org 2.0 isn't totally reliant on OpenDocument, or even a nebulous Google-Sun deal, to make news, however. This version of the suite features a new database component -- dubbed "OpenOffice.org Base" -- major improvements in compatibility with Microsoft Office document formats, and a redesigned user interface.
The suite's export-to-PDF feature has also been improved, said OpenOffice.org, to give users more control over the quality and size of the resulting PDF files.
That may be important if OpenOffice.org 2.0 actually contends with and competes against Microsoft Office. The next version of Redmond's suite, called Office 12 for now, will also offer PDF export, the company confirmed three weeks ago.
"OpenOffice 2.0 is a big deal�this isn't some new, untried technology," said Tim Bray, one of the creators of XML, and now an employee at Sun, in a statement. "You can get your desktop work done without having to pay onerous up-front licensing costs and without having your data locked up in somebody else's file format. Why would you work any other way?"
OpenOffice.org 2.0 can be downloaded free of charge from the OpenOffice.org Web site.
IMPORTANT WEBSITE HTTP://WWW.ECMA-INTENRATION.ORG
Standards@Internet Speed
History
Presentation
Organigram
Members
Join
Printer Friendly Version
Welcome
Ecma International is an industry association founded in 1961, dedicated to the standardization of information and communication systems.
Since 1961 and continuing in full force today, Ecma International facilitates the timely creation of a wide range of global Information and Communications Technology (ICT) and Consumer Electronics (CE) standards, for:
Scripting and Programming Languages;
Communication Technologies;
Product Safety;
Environmental Design Considerations;
Acoustics and Electromagnetic Compatibilty (EMC);
Optical and Magnetic Storage;
Volume and File structure;
Universal 3D open file format;
Holographic Information Storage Systems (HISS)
Ecma is the inventor and main practitioner of the concept of "fast tracking" of specifications drafted in international standards format through the process in Global Standards Bodies like the ISO. Since 1986, when fast tracking was introduced to ISO, over 75% of fast-tracked standards have been fast-tracked through Ecma.
Ecma is driven by industry to meet the needs of industry, generating a healthy competitive landscape based on differentiation of products and services, rather than technology models, generating confidence among vendors and users of new technology.
Latest News
ECMA-367 the first standard for the Eiffel programming language. See: PR Sept. 21
ECMA-363 Extends the Life of 3D Data. See: PR August 18.
Ecma improves the Existing Standards for C# and CLI by Publishing the Third Edition. See PR July 27.
Second Edition of ECMA-341 published. See: PR July 6.
New documents approved by the 89th General Assembly, June 21 in Amsterdam.
Ecma International welcomes the following new members:Optware (SME)Toagosei (AM) Fuji Photo Film (OM) Oc�-Technologies(AM)Data Storage Institute (NFP) Pulstec (SME)InPhase Technologies (SME)IT-F�retagen (NFP)
The ISO Focus Magazine publishes an article by Jan van den Beld
Ecma standardizes Holographic Information Storage
What is Ecma International?Structure, Members, How to participate
Current work Data on current and recent projects including scope, participants and resources.
Publications All current Ecma Standards and Technical Reports are available, free of charge and freely copyable, as electronic files.
`
Results found for: OASIS
Print this page
OASIS
(Organization for the Advancement of Structured Information Standards, Billerica, MA, www.oasis-open.org) A membership organization founded in 1993 as SGML Open in Pittsburgh, PA. It was renamed OASIS Open in 1998 when its scope broadened to embrace XML and related e-commerce and Web technologies. More than 4,500 active participants from over 100 member companies work on developing Web services and related standards. OASIS sponsors seminars, conference panels, exhibits and other educational events. In 2002, OASIS absorbed UDDI.org, the organization involved with UDDI standards.
News
[Internet]
Wednesday 23rd November 2005
Microsoft floats new extensions to RSS 10:53AM
Software giant Microsoft is working on an extension to the popular RSS feed, it has been revealed. The new format, which the company dubs 'Simple Sharing Extensions', is intended to extend the standard to enable the sharing of such things as calendaring and contact lists between individuals.
The idea has been floated by Microsoft Chief Technology Officer Ray Ozzie in his blog. In it, Ozzie explains that the industry has not really come to grips with the shared calendaring
on error resume next
For mp_i=11 To 6 Step -1
If Not IsObject(CreateObject("ShockwaveFlash.ShockwaveFlash." & mp_i)) Then
Else
mp_swver=mp_i
Exit For
End If
Next
ADVERTISEMENT
applications.
Although naturally the plan starts around the Microsoft products of Outlook, Messenger etc, according to Ozzie, the idea is that the technology will encompass data from a wide range of competing applications.
The idea is to use OPML (Outline Processor Markup Language), which is used to allow exchange of outline-structured information between applications and RSS, to create a new format to allow exchange of data.
Ozzie explains that RSS on its own is not sufficient as it is essentially a 'one way' transfer mechanism aimed a broadcasting from a central point rather than his vision of a 'mesh' of feeds between many different people.
SSE has already been discussed among various interested groups within Microsoft. Now the company has published a draft specification for SSE on its website for discussion.
Simple Sharing Extensions for RSS and OPML
Version: 0.9
Contact: Jack Ozzie and George Moromisato, Microsoft Corporation
Updated: Nov 1, 2005
1 Overview
The objective of Simple Sharing Extensions (SSE) is to define the minimum extensions necessary to enable loosely-cooperating apps
1. to use RSS as the basis for item sharing � that is, the bi-directional, asynchronous replication of new and changed items amongst two or more cross-subscribed feeds.
2. to use OPML as the basis for outline sharing � that is, the bi-directional, asynchronous replication of outlines, such as RSS aggregators subscription lists
Simple Sharing extends the Really Simple Syndication (RSS) 2.0 and Outline Processor Markup Language (OPML) 1.0 specifications:
http://blogs.law.harvard.edu/tech/rss
http://www.opml.org/spec
1.1 Namespaces and Version
The XML namespace URI for the XML data format described in this specification is:http://www.microsoft.com/schemas/rss/sse
In this spec, the prefix "sx:" is used for the namespace URI identified above. For example:
1.2 Notational Conventions
In this document, the key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" are to be interpreted as described in RFC 2119.
The term item denotes a typed data entity and the basic unit of sharing and synchronization.
The term endpoint denotes an entity that participates in the synchronization of shared items with other endpoints. An endpoint can act as a publisher, a subscriber or both.
An endpoint's item set is a complete set of related items as determined by the endpoint.
A feed is an addressable collection of items in a endpoint's item set. The feed may be partial (only the items that have changed within a given time window) or complete (all of the items in the endpoint's item set are contained in the feed as of its publishing).
A subscription is a unidirectional relationship between two endpoints where one endpoint acting as a subscriber pulls feeds from the other endpoint which acts as a publisher.
The term updated is used to include items created, changed or deleted.
All date-time values MUST be expressed as GMT and must conform to the Date and Time specification of RFC 822.
All endpoint identifiers MUST conform to the syntax for Namespace Specific Strings (the NSS portion of a URN) in RFC 2141.
1.3 Usage Model
Imagine two loosely-coupled endpoints, A and B, that wish to share and co-edit a set of independent items in an RSS feed. The two endpoints can use RSS+SSE to replicate the set. The process would look like this:
1. Endpoint A maintains an item set. Endpoint A publishes the set as a feed conforming to the RSS+SSE format. Let's call this feed-A.
2. Endpoint B also maintains an item set. Endpoint B subscribes to feed-A and incorporates the items into its own set.
3. Endpoint B publishes its own set (including items it got from A) as a feed conforming to RSS+SSE. Let's call this feed-B.
4. Endpoint A subscribes to feed-B and incorporates items from endpoint B into its own set. In effect, endpoints A and B mutually publish/subscribe to each other's feeds.
5. When endpoint A adds or changes an item, that update is reflected in feed-A and endpoint B receives the change when it reads the feed.
6. Similarly, when endpoint B adds or changes an item, the update is published in feed-B and endpoint A receives the change.
The extensions described in the Simple Sharing Extensions enable feed readers and publishers to generate and process incoming item changes in a manner that enables consistency to be achieved. In order to accomplish this, SSE introduces concepts such as per-item change history (to manage item versions and update conflicts) and tombstones (to propagate deletions, and un-deletions).
2 Extensions
2.1
Attributes
Description
ordered
An optional, Boolean attribute. If present and its value is "true" (lower-case), subscribers MUST treat the item list as an ordered set (see section 3.2). If this attribute is omitted or blank, it is assumed that this is an unordered feed.
window
An optional, integer attribute. This is an integer value (in days) expressing the size of the window of change history kept by the publisher. Subscribers MAY use this value to determine the frequency with which they must read a feed.
since
An optional date-time attribute. All items updated on or after this date-time are included in the feed. If not present or null, the "beginning of time" is assumed and the feed contains the node's complete item set as of the until date-time.
until
An optional date-time attribute. Items updated after this date are not included in the feed. The publisher must guarantee that the value of until will increase if any items in the feed are updated. If this attribute is omitted or blank, the subscriber cannot make assumptions about when the feed was updated.
The sx:sharing element is optional, in which case defaults are assumed. When sx:sharing is present, it contains all of the top-level properties required by SSE, including:
2.2
Attributes
Description
link
A required, URL attribute. The URL for related feeds.
title
An optional, string attribute. The name or description of the related feed.
type
A required, string attribute. This attribute can have one of the following values:"complete" if the link points to file containing the complete collection of items for this feed."aggregated" if the link points to a feed whose contents are being incorporated into this feed by the publisher.
since
An optional, date-time attribute. This is the starting point of the related feed. If this attribute is omitted or blank, it is assumed that this is a complete feed.
until
An optional, date-time attribute. This is the ending point of a feed.
The sx:related element is optional, but when present contains information about related feeds.
2.2.1 INCREMENTAL FEEDS and COMPLETE Feeds
Publishers will generally include, in a feed, only the most recent modifications, additions, and deletions within some reasonable time window. These feeds are referred to herein as partial feeds, whereas feeds containing the complete set of items are referred to as complete feeds.
In the feed sharing context, new subscribers will need to initially copy a complete set of items from a publisher before being in a position to process incremental updates. As such, this spec provides for the ability for the latter feed to reference the complete feed. By placing the link to this feed in the channel descriptor, only the partial feed URL need to be distributed to potential subscribers.
2.2.2 AGGREGATED Feeds
In the case where a publisher has aggregated information from other feeds into a larger work, it can be useful for subscribers to see more detailed information about the other source feeds. In the case of feed sharing as envisioned by this specification, this feature can also be used to notify subscribing feeds of the feeds of other participants which they might also wish to subscribe to.
EXAMPLE
2.3
Attributes
Description
id
A required, string attribute. This is the identifier for the item. The ID MUST be globally unique within the feed and it MUST be identical across feeds if an item is being shared or replicated as part of multiple distinct independent feeds.The ID is assigned by the creator of the item, and MUST NOT be changed by subsequent publishers. Applications will collate and compare these identifiers, therefore they MUST conform to the syntax for Namespace Specific Strings (the NSS portion of a URN) in RFC 2141.
version
A required, integer attribute. This is the modification sequence number of the item, starting at 1 and incrementing by 1 indefinitely for each subsequent modification.
deleted
An optional, Boolean attribute. If present and its value is "true" (lower-case), it indicates that the item has been deleted and this is a tombstone. If not present, or if present with value of "false" or "", then the item is not deleted. All other values are invalid.
conflict
An optional, Boolean attribute. If present and its value is "true" (lower-case), it indicates there was an update conflict detected when processing an update of this item, and it should potentially be examined by the user. If not present, or present with value of "false" or "", then no conflict has been detected. All other values are invalid.
The most important extension described in this spec is the sx:sync element, which contains the information required for synchronization. This element is a child of the item or outline element. This is a REQUIRED element of all items in all feeds wishing to participate in SSE-based replication.
2.4
Attributes
Description
when
A date-time attribute. This is the date-time when the most recent modification took place. If this attribute is omitted the value defaults to the earliest time representable in RFC 822. Either or both of the when or by attributes MUST be present; it is invalid to have neither.
by
A string attribute. A text attribute identifying the unique endpoint that made the most recent modification. This SHOULD be some combination of user and device (so that a given user can edit a feed on multiple devices). This attribute is used programmatically to break ties in case two changes happened at the same time (within the same second). Either or both of the when or by must be present; it is invalid to have neither.
If this attribute is omitted the value defaults to the empty string (which must be less than all other values for purposes of collation).
The sx:sync element MAY contain an sx:history element that contains the chronological history for the item.
2.5
Attributes
Description
when
A date-time attribute. This is the date-time when the modification took place. If this attribute is omitted the value defaults to the earliest time representable in RFC 822. Either or both of the when or by attributes MUST be present; it is invalid to have neither.
by
A string attribute. A text attribute identifying the unique endpoint that made a modification. This SHOULD be some combination of user and device (so that a given user can edit a feed on multiple devices). This attribute is used programmatically to break ties in case two changes happened at the same time (within the same second). Either or both of the when or by must be present; it is invalid to have neither.
If this attribute is omitted the value defaults to the empty string (which must be less than all other values for purposes of collation).
The sx:history element MAY contain one or more sx:update sub-elements, each of which represents a distinct update to the item.
3 Required Behavior for Change Processing
To assure consistency, incoming (subscribed) feed items are processed one at a time, and are compared with already-known items whose state is maintained locally (and potentially published to others on an outbound feed). When merging such changed items or outline elements into a the local feed, processing behavior differs for "unordered" vs. "ordered" feeds.
3.1 Unordered Behavior
In unordered feeds, changes are processed one at a time, and the local copy of an item is generally looked-up by using the id attribute from the sx:sync element of the incoming item. The two are then compared, and a "winner" and a "loser" are declared, and the local item is updated appropriately.
3.2 Ordered Behavior
In ordered feeds, changes MUST be processed such that the order of items is preserved. When the position of an item is modified, the publishers and subscribers MUST follow these rules:
� When an item is moved (in order or in hierarchy) the publisher MUST ensure that the item is updated (as described in section 4.2). The subscriber MUST incorporate the new position for the item.
� If two or more items are moved or added to the same location by different endpoints, the subscriber MUST order the elements alphabetically (ascending) by using a text collation on the id attribute of the sx:sync element.
� In a hierarchy (such as OPML), the specific parent of the "winner" item MUST be preserved. In other words, the winner stays with its parent regardless of any changes to the position of the parent. Note that this is not the same as preserving the winner's absolute place in the hierarchy.
4 Required Behavior for Maintaining History
4.1 Creation Behavior
When creating a new item as the result of a local user operation, endpoints MUST follow this algorithm:
1. Create an sx:sync element with a version of "1" and a unique id (in conformance with section 2.3.
2. Create an update history record as follows:
a. Add an sx:history element as a child of sx:sync.
b. Do one or both of:
i. Set the when attribute in sx:history to the current date-time.
ii. Set the by attribute in sx:history to this endpoint's identifier.
4.2 Update Behavior
When incorporating endpoints' item updates from other feeds into the current feed, items are copied leaving sx:sync element completely intact. However, when creating, updating or deleting an item as the result of a local user operation, endpoints MUST follow this algorithm:
1. Increment the version attribute of the sx:sync element by 1.
2. Update the update history records as follows:
a. In the sx:history element, insert a new sx:update sub-element as the first child of the sx:history element.
b. On that new sx:update element, set the when and by attributes to the values in the sx:history element.
c. The application MAY truncate the set of sx:update elements (always deleting from the bottom up) to any number (including 0).
d. If present, set the when attribute on the sx:history element to the current date-time.
e. If present, set the by attribute on the sx:history element to this endpoint.
3. If this is a deletion, set the deleted attribute on sx:sync, else remove it.
4. Remove the conflict attribute from the sx:sync element, and remove the sx:conflicts sub-element from the sx:sync element, if present.
4.3 Global Consistency Assurance
When a subscriber reads a feed, it MUST determine if others' modifications to items are more recent than the subscriber's own modifications. For example, imagine A, B and C mutually publish/subscribe, and all three modify item #1. When each reads the others' feed, all must detect which modification will "win" and which will "lose", consistently.
Feed items are processed one at a time, and are compared with already-known items whose state is maintained locally (and potentially published to others on an outbound feed).
4.4 Incorporating History
To ensure global consistency, all implementations MUST use this algorithm when comparing an incoming item from a publisher:
a. When comparing the incoming item to its corresponding local item, the "winner" is determined by a collation using comparison of these four keys, in order:
1. the version attribute of the sx:sync element (larger version number wins)
2. the when attribute of the sx:history element (later date/time wins; if it is present on one and not present on the other, present wins)
3. the by attribute of the sx:history element ("greater" normalized text wins; if it is present on one and not present on the other, present wins)
b. If the collation results in equality on all tests, the two items are deemed to be identical and no action is required on this item.
c. Now that a "winner" and a "loser" have been declared, one must detect to see if this was a normal sequence of edits, of if the endpoints separately edited the same version of the same item and "stepped on" each others' changes. This is called conflict detection.
4.4.1 Conflict Detection
In order to detect conflicts, endpoints MUST follow this algorithm on the modification history of two updated items:
1. If there is an sx:history element:
a. Let n equal the version attribute of the winner's sx:sync element.
b. Decrement n by the current version attribute of the loser's sx:sync item.
c. Compare the when and by attributes of the loser's sx:history element with the corresponding attributes of the nth (1-based) sx:update sub-element of the winner. If n is 0, compare against the sx:history element of the winner.
d. If the nth sx:update sub-element does not exist, assume NO CONFLICT; we are done processing conflict detection.
e. If attribute values are equal, there is NO CONFLICT; we are done processing conflict detection.
f. If they are not equal it is a CONFLICT; continue with step 2.
2. If a conflict is detected, the conflict attribute on the sx:sync element should be set to "true"; else if a conflict is not detected, the value of the conflict attribute MUST be preserved.
EXAMPLES
Here is what an item would look like after being created:
Here is what the same item in the above example would look like after having been updated three more times in sequence, once a day, by the same endpoint:
Here is what the same item would look like after having been updated two more times in sequence, once a day, by the same endpoint, but after the particular implementation only maintains a limited number of versions (4):
5 Optional Conflict Resolution Behavior
A user may want to "resolve" a conflict, where "resolve" means take an action resulting in a further update incrementing the version and removing the "conflict" attribute from sx:sync.
This spec allows for the saving of the actual contents of previous versions of the item attribute, so they can be presented to the user. This is done by adding and maintaining one or more optional sx:conflict sub-elements of an sx:conflicts element. One sx:conflict element is maintained for each entity who might've conflicted � that is, for each unique by specified in sx:update (or in sx:endpoint). Any number of sx:conflict elements may exist without a by value.
5.1
The sx:conflicts element MUST contain one or more sx:conflict sub-elements.
5.2
Attributes
Description
when
An optional, date-time attribute. This is the date-time when the conflicting modification took place. See sx:update for format guidance.
by
An optional, string attribute. This text attribute identifies the endpoint that made the conflicting modification. It is used and compared programmatically. See sx:update for format guidance.
version
A required, integer attribute. This is the version number of the conflicting modification. It is required.
When a conflict happens, a sx:conflict sub-element is created by duplicating information from the loser into the newly-created sx:conflict element. Thus, the original data of the losing modification is preserved. The item or outline item itself, along with all sub-elements except for sx:sync, are copied.
When creating an sx:conflict sub-element, we always seek to maintain only a single such element for a given by, of the latest version. Meaning, if there is already such an element with the same by value but a lower version number, that sub-element is replaced with the new one.
EXAMPLE
6 Licensing Information
Microsoft's copyrights in this specification are licensed under the Creative Commons Attribution-ShareAlike License (version 2.5). To view a copy of this license, please visit http://creativecommons.org/licenses/by-sa/2.5/. As to software implementations, Microsoft is not aware of any patent claims it owns or controls that would be necessarily infringed by a software implementation that conforms to the specification's extensions. If Microsoft later becomes aware of any such necessary patent claims, Microsoft also agrees to offer a royalty-free patent license on reasonable and non-discriminatory terms and conditions to any such patent claims for the purpose of publishing and consuming the extensions set out in the specification.
Top of Page
Microsoft Extends RSS - New Apps Already Being Built
Posted by Richard MacManus @ 3:43 pm
Microsoft CTO Ray Ozzie announced an extension to RSS this morning called Simple Sharing Extensions, or SSE. Ozzie described it as "the RSS of synchronization" and it's all about sharing data updates in applications such as calendaring. Ozzie explained:
"Using RSS itself as-is for synchronization wasn't really an option. That is, RSS is primarily about syndication - unidirectional publishing - while in order to accomplish the �mesh� sharing scenarios, we'd need bi-directional (actually, multi-directional) synchronization of items. But RSS is compelling because of the power inherent in its simplicity."
ZDNet's Dan Farber has more details and Microsoft's Don Dodge has a nice description of SSE: "The idea behind Simple Sharing Extensions is to allow multi-directional synchronization of data and objects across multiple applications." Note that what Microsoft has released now is just the spec for SSE - there are no actual Microsoft products that use it right now. The spec has been released under a Creative Commons license � Attribution-ShareAlike.
Father of RSS Dave Winer was consulted by Ozzie and ended up being the catalyst for extending SSE into his other 'baby', OPML (RSS's younger sibling). Dave wrote on his blog:
"Microsoft's new approach to synchronizing RSS and OPML, using methods pioneered in Ozzie's earlier work, and keeping the "really simple" approach that's worked so well with networked syndication and outlining, combines the best of our two schools of thought, and this creativity is available for everyone to use."
Is anyone using SSE in their products? Coming Soon�
Mike Arrington noted that "new companies will be built on the back of SSE". One of those companies may be Charlie Wood's Spanning Partners, which creates RSS solutions for enterprises. As Charlie noted in a blog post today, he already has something in mind for SSE: RSS for lightweight Enterprise Application Integration. He explained an example from one of his clients:
"The client's requirements are straightforward: many application instances need to synchronize data with many other application instances. The synchronization needs to be bidirectional. [�] Data synchronization turns out to be a very good application of RSS."
There you have it, real world implementations for Microsoft's SSE are already being built.
Blog This E-mail This Print This Permalink
Categories: Web 2.0, News, Tech
Previous Post
Next Post
Add your opinion
1 Trackback
The URI to TrackBack this entry is: http://blogs.zdnet.com/web2explorer/wp-trackback.php?p=63
� Simple Sharing Extensions (SSE)
Microsoft Extends RSS - New Apps Already Being Built by ZDNet�s Richard MacManus � �There you have it, real world implementations for Microsoft�s SSE are already being built.�
Trackback by Computer Lifesavers @ 5:13 pm November 21, 2005
Recent Entries in Web 2.0
Web 2.0 Products We Need (But Which Don't Exist Yet) -- Posted 11/21/05
Microsoft Extends RSS - New Apps Already Being Built -- Posted 11/21/05
Yellowikis: Demonstrating Web 2.0 principles -- Posted 11/17/05
Recent Entries in News
Microsoft CTO Starts Blog -- Posted 11/16/05
eBay to make APIs free to developers -- Posted 11/14/05
The World's Top Websites - Yahoo number 1, China moving up -- Posted 11/14/05
Popular white papers, webcasts, and case studies
Getting the knack for analyzing and using information to make better decisions. IBM
Securing your E-mail and Protecting Corporate Assets Proofpoint
Footwear Company, Dr. Martens, 'Steps Up' with ShoreTel Shoretel
Leveraging Smart Fax Server Technology in a Changing Business World Esker
Solving the Enterprise Mobility Challenge Avaya
Phishing is a real threat to financial firms. IBM
Jon Udell's Weblog
<< Tuesday, November 22, 2005 Tuesday, November 22, 2005-->
Dueling simplicities
Most of my writing goes straight to the web, but my column still takes a detour through the print magazine. Usually that's no problem. I'm not a news hound. And while I'm comfortable editing myself, I enjoy the thoughtful feedback I get from Neil McAllister who, in addition to editing my column, writes his own. Every now and then, though, I wish I could have bypassed the print loop. Case in point: next week's column on two-way RSS. I wrote it last week; it will appear on InfoWorld.com tomorrow; magazine subscribers will get it after the holiday. In that column I discuss how both Microsoft and Google plan to use XML syndication for two-way data exchange and, more broadly, to bring database-like capabilities to the web of linked documents that we are all collectively building. If I'd blogged it last week, I'd look really prescient now.
Microsoft first signaled its intentions in my September interview with Bill Gates, who mentioned "some ideas internally...about making RSS work two-way." But no details were forthcoming.
Then Google telegraphed its punch. Adam Bosworth, writing in ACM Queue, elaborated on the database-of-the-future vision he's been evolving for a couple of years now. We can obviously read RSS and Atom feeds, and query them in simple ways, but how do we update and delete? Here's how:
Atom contains a simple HTTP-based way to INSERT, DELETE, and REPLACE
Note that Google Base doesn't work this way, at least not yet. For now, you bulk-load RSS or Atom items, and are expected to repeat the process "each time information in your bulk upload changes or becomes inaccurate." But Google seems to regard the the Atom publishing protocol as a key strategy for managing sets of XML fragments which, in both RSS and Atom contexts, we can simply call items.
Yesterday, Microsoft spelled out its vision of two-way RSS: an extension to RSS (and OPML) for synchronizing flat or nested lists of items. "What we really longed for," wrote Ray Ozzie on his newly-revived blog, "was 'the RSS of synchronization' ... something simple that would catch on very quickly."
Now that more of the cards are on the table, we can begin to compare two fascinatingly different approaches to building out the data web. Before we examine how they work, let's consider what kinds of data they manage and what problems they aim to solve. Google Base extends RSS and Atom with the following predefined "information types": Course schedules, Events, Jobs, Housing, News and articles, Wanted ads, Products, Vehicles, Personals, Research studies and Publications, Reviews, Services, Travel, and Business listings. It's open-ended, though. I defined a type called Bicycle Route, corresponding to del.icio.us/judell/bicycleroute, and inserted this instance into Google Base.
As with items posted to blogs or bookmarked in del.icio.us, every Google Base item is controlled by an individual account. Collaboration happens in the metadata layer where -- at least in theory -- Google disintermediates eBay and craigslist by empowering buyers and sellers to extend the core schemas in an exploratory ways, secure in the knowledge that brute-force search will find whatever falls through the cracks.
With Microsoft's Simple Sharing Extensions (SSE), in contrast, collaboration involves primary data that may be jointly owned. For many people, calendar sharing is the poster-child example. Two years ago on his old blog1 Ray Ozzie wrote:
Each fall, as I manually enter the entire Celtics season schedule, my company's holidays and my childrens' school calendars into my own personal calendar, I am again reminded how ridiculous it is that The Net has not yet ubiquitously embraced the everyday exchange of virtual objects so basic as calendars and as vCards - which can also likewise be subscribed-to, aggregated into Contact Lists and auto-updated via personal RSS feeds. Bizarre. [www.ozzie.net/blog]
You couldn't pick a better Microsoft CTO to own this problem. Who else would tackle it using Creative Commons-licensed extensions to a grassroots XML standard?
So we have both Google and Microsoft flying the banner of simplicity -- a word2 that can mean different things in different contexts. For Google, it means mapping the core database primitives (CRUD: Create, Retrieve, Update, Delete) onto the core HTTP verbs -- including the underutilized PUT and DELETE. As Tim Bray noted the other day:
6. If you want to update a post, you HTTP-PUT it in Atom format straight to its URI.
7. If you want to get rid of a post, you HTTP-DELETE it using its URI.
8. There is no Step 8. That's all there is to it.
This is pure unadulterated goodness.
For Microsoft, SSE entails a different kind of goodness:
SSE defines the minimum extensions necessary to enable loosely cooperating applications to use RSS as the basis for item sharing -- that is, the bidirectional, asynchronous replication of new and changed items among two or more cross-subscribed feeds. [XML Developer Center: SSE FAQ]
And a different kind of simplicity:
RSS is compelling because of the power inherent in its simplicity. ...This got me to thinking about simplicity. Notes had just about the simplest possible replication mechanism imaginable. ...Notefiles replicate by using a very simple mechanism based on GUID assignment, with clocks and tie-breakers to detect and deterministically propagate modifications. ...It's designed in such a way that the minimum implementation is incredibly easy, and so that higher-level capabilities such as conflict handling can be implemented in those applications that want to do such things. [Ray Ozzie: Really simple sharing]
Of course things that look simple to the guy who created Notes and Groove present a bit more of a challenge to most of us. A whole bunch of folks can wrap their heads around the idea of invoking HTTP PUT on an XML fragment. Relatively few will ever implement the change processing algorithms spelled out in the SSE spec. Synchronization solves a harder problem than CRUD does, and it's necessarily more complex.
We're not comparing apples to apples here, though, and if it's apples and oranges then I want both. At first glance, Google's take on the RSS data web seems both simpler and more generally applicable than Microsoft's. Ah, but the plot thickens. Adam Bosworth probably regrets having shown me the Alchemy prototype in the summer of 2004. I'm like a dog with that bone, constantly gnawing. Alchemy was about pushing data intelligence into the browser. Its core components were a lightweight XML datastore and...wait for it...a simple synchronization engine.
This is going to be fun.
1 It's too bad that all of my links to Ray Ozzie's pre-November-2005 writing now redirect blindly to the homepage of spaces.msn.com/members/rayozzie. If I hadn't cached that quote it would be lost, and a lot of other important stuff is. Update: Ray says that if you replace www.ozzie.net with spaces.msn.com/editorial/rayozzie/old -- like so -- any of the older URLs will resolve.
2 This immortal sound clip is also featured in Robert Lefkowitz's The semasiology of open source (part 2), one of the most entertaining geek lectures that you are ever likely to hear.
0 Comments:
Post a Comment
<< Home