Today, we are proud to announce the general availability of version 2.0 of the Restlet Framework, representing about 2 years of work since version 1.1! This is truly a major release, equivalent to the initial effort that took us from the project launch to the 1.0.0 release.

What’s new ?

Restlet editions

After targeting standalone Java SE virtual machines and Java EE web containers in version 1.0, we introduced a manual port to GWT in version 1.1. During the development of version 2.0, we jumped on two new bandwagons launched by Google:

• Android for web connected smartphones and tablets
• GAE for cloud computing hosted applications

As each port required a lot of manual maintenance, we developed a special Restlet forge including a fully automated port mechanism that allows us to work on a single code base while taking into account the specificities of each target environment.

As a result, the framework is now available in five consistent editions covering the most popular Java-based platforms.

Package restructuring

While maintaining an easy migration path from version 1.1, we took the opportunity of this major release to reorganize Restlet extensions, moving “com.noelios.restlet.ext” packages into “org.restlet.ext” ones, merging the “com.noelios.restlet.jar” into a single core “org.restlet.jar” including both the Restlet API and the core engine.

Enhanced Restlet API

We completed our support for HTTP headers, mapping almost all standard ones to the Restlet API as illustrated in this mapping table and also introduced a higher level way to develop Restlet resources that works equally well on both client and server side.

Those new ServerResource and ClientResource classes support the traditional class-oriented approach previously used in Restlet and added on top of it using custom Java annotations, providing the benefits of the JAX-RS API (that we keep supporting as a Restlet extension) but with much less annotations (just 5 currently) and a rich and extensible Java API as a solid foundation.

As a result, you can use representation beans that can get automatically serialized to and from XML, JSON, GWT object, Java object formats thanks to extensions such as Jackson, XStream, JiBX or JAXB.

We also added a brand new security API that supports HTTP centric authentication and authorization in simple yet extensible way, for example with extensions for the JAAS, jSSLutils and javax.crypto APIs.

OData extension

A new extension for OData technology was added, thanks to a collaboration with Microsoft Interop teams. It provides a high-level client API based on the ClientResource class that lets you access remote OData services, typically hosted in an ASP.NET servers or on the Windows Azure cloud computing platform.

The extension contains both a code generator for the representation beans and a runtime layer. Advanced features such as projections, blobs, server-side paging, row counts, customizable feeds or version headers are supported.

RDF extension

We also want to make Restlet a great framework for building applications for the Semantic Web. The relationship between REST and RDF is perfect : the core concept of resources and their representations with REST and the expression of meaningful links between them with RDF.

This new extension contains a full RDF API, leveraging the Restlet API, and capable of processing RDF documents either in a DOM-like way or in a SAX-like way. It is also capable of writing large RDF documents is a SAX-like way. We currently support two serialization formats: RDF/XML, RDF/n3, Turtle and N-Triples. Finally, a RdfClientResource class facilitates the hypermedia navigation in the Web of Data.

Other changes

It is impossible to be exhaustive in such a post, but we have collected all major changes in our new user guide. For those interested in a more exhaustive list, there is always the changes log.

“Restlet in Action” book

Last year we have started writing a book on the Restlet Framework for Manning. It will contain 12 chapters covering all major aspects of Restlet applications development and RESTful web APIs design based on our home-grown ROA/D methodology.

Today, we released chapter 6 on documenting and versionning web APIs, as well as chapter 7 on Restlet security contributed by Bruno Harbulot. To celebrate version 2.0.0 release, Manning is offering to Restlet users a time limited 35% discount with the “rest35au” code. Happy reading!

What’s next

Today is a time to step back and thank our community of users and contributors, all readers providing feed-back on the book in the authors’ forum or during the external review and of course to our growing list of customers at Noelios Technologies, the commercial entity backing the open source project, making this open source project economically sustainable.

After nearly 5 years after the project launch, the road ahead has never been as exciting. REST is finally recognized as the best way to design web applications and distributed architectures in general.

We have already prepared a roadmap for version 2.1 which will add incremental features such as better hypermedia support, enhanced converter service, a pure JavaScript edition, production-ready internal HTTP connectors based on non blocking NIO, support for VoIP via SIP and an even better user documentation.

Your feedback, funding and continuous support will make a difference.

Best regards,

Jérôme Louvel – Founder and Technical lead
ThierryBoileau – Core developer and Community manager

Contributors since 2.0 RC4

• Aleskandr Shekhter
• Alex Milowski
• Alexander J. Perez Tchernov
• Alistair Dutton
• Bruno Harbulot
• Christopher Gokey
• David Fogel
• Dustin Jenkins
• Eric Hough
• Felix Leipold
• Giovani Pieri
• Greg Hengeli
• Guillaume Maillard
• Guillermo Vega
• Iestyn Evans
• Jeroen Goubert
• Kristoffer Gronowski
• Louis Huh
• Martin Svensson
• Rickard Oberg
• Sriram Chavali
• Tim Kuntz
• Tim Peierls
• TK Kocheran
• Valdis Rigdon
• Vassilis Touloumtzoglou

Thanks to all others who helped us in various ways during the 2.0 development!

Additional resources

Changes log:
http://www.restlet.org/documentation/2.0/jse/changes

Download links:
http://www.restlet.org/downloads/testing

Maven repositories:
http://maven.restlet.org is updated on the 1st and 15th of each month
http://maven.noelios.com is updated daily with new artifacts (access reserved to subscribers)

Updates

• Xebia – Press review covering release of Restlet Framework 2.0 (in French)

Main changes

• Character oriented subclasses of OutputRepresentation now extend WriterRepresentation for consistent character set handling. StringRepresentation now derives from CharacterRepresentation. This fixed several character set issues in extensions such as GWT, XStream, Jackson or JAXB.
• Status name is now returned to clients for display instead of the status description, in order to not expose internal information by default for security reasons. It is also shorter and doesn’t normally contain line feeds and carriage return forbidden characters.
• OData extension issues related to complex types generation, redirection or unnecessary client connector instantiations were fixed.
• Engine class was refactored to allow the usage of Restlet in constrained environments (such as Applets) where it is forbidden to create a new classloader.
• Security related classes (JaasVerifier, DigestAuthenticator and DigesterRepresentation) were fixed.
• Unecessary log entries under Android were removed, due to usage of BufferedReader without specifying a buffer size.
• The design of the Engine class was fixed to allow custom subclasses to be registered without systematically creating a new EngineClassLoader. This is useful when the security manager is activated. A typical use case is for running Restlet inside Applets.
• Deprecated GwtShellServletWrapper and WadlResource classes, SpringBeanFinder#getSpringBeanRouter method.
• Javadocs improvements with links to online user guide (wiki) and more detailed description of classes such as ServerResource and Finder.
• Optimization of StringRepresentation#getStream() speed by a factor 10 using the ByteArrayInputStream().
• Clarified server connector start message by displaying the protocol and the port number they are listening on.

Direct contributors

• Alex Milowski
• Bruno Harbulot
• George Calm
• Jean-Baptiste Dusseaut
• Jean-Philippe Steinmetz
• Kevin Pauli
• Marc Knaup
• Martin Krasser
• Matthew Drooker
• Myriam Leggieri
• Pierre-Yves Ricau
• Rob Heittman
• Roger Heim
• Tal Liron
• Thierry Templier
• Yang Xudong

Thanks to all others who helped us in various ways!

Additional resources

Changes log:
http://www.restlet.org/documentation/2.0/jse/changes

Download links:
http://www.restlet.org/downloads/testing

Maven repositories:
http://maven.restlet.org is updated on the 1st and 15th of each month
http://maven.noelios.com is updated daily with new artifacts (access reserved to subscribers)

However, even though deploying Restlet components and applications in an OSGi environment is already possible and explained in the user guide, it doesn’t take advantage of the dynamic and extensible nature of OSGi. Today, Bryan Hunt pointed me to a great tutorial written by Wolfgang Werner that nicely describes the Restlet Framework, covers its usage with Eclipse’s Plugin Development Environment (PDE) and explains how to leverage Equinox’s extension points to dynamically register Restlet components, applications and resources. See the series of posts titled “Building web services on Equinox and Restlet”:  part #1, part #2 and part #3.

But wait, there is more good news as a Google Summer of Code 2010 project “Restlet integration with Equinox” was proposed by the Eclipse Foundation and just accepted by Google! Thanks to Bryan Hunt for initiating the effort, to Equinox’s development team for supporting it, including Jeff McAffer, Simon Kaegi and Scott Lewis. We also received a positive review from Benjamin Cabé, an Eclipse contributor. Thanks also to all supporters including Jeff Norris and Khawaja S Shams from NASA, Rob Heittman from Solertium and Thierry Templier.

Two students proposals were submitted, one from Rajeev Sampath and another one from Samrat Dhillon. The first one was finally selected but Samrat has offered to contribute to the project. Rajeev is a Computer Science undergraduate student from University of Moratuwa, Sri Lanka, with good Java and distributed system experience as illustrated by his participation to the Epzilla project on Complex Event Processing (CEP).

I’m very happy to see this project, initiated by the Restlet community, taking shape and wish it full success. At Noelios Technologies, we will support it as co-mentor and encourage other interested parties to join and contribute. The project web site at Google Code is here… stay tuned!

Updates:

• EclipseSource – Google Summer of Code 2010 is on!
• EclipseLabs – Restlet integration with Equinox
  

About one month after RC2, here comes a new release candidate. We fixed about 20 issues, including bugs and API problems. Final 2.0.0 version is still scheduled for the end of June 2010 and we are already quite happy about the overall stability.

In addition, Restlet Framework version 1.1.10 was released, fixing three bugs (unwanted console trace, WADL “Resource” element order and “content-length” header for range requests).

Main changes

• Thread blocking issues with the internal HTTP client connector were fixed.
• The internal HTTP client works again on the Android edition.
• Fixed issues preventing multi-threaded usage of ClientResource and dynamic client proxies.
• Fixed concurrency bug with annotated interfaces causing
  405 errors (method not allowed).
• HTTP proxy configuration was added to internal HTTP client connector.
• Removed lesser used MediaType constants in the GWT edition to reduce the compiled size by 6 Kb. Now using Restlet in your GWT application only adds 159 Kb of JavaScript. If you GZip your HTTP traffic, this even gets down to 65 Kb. See this issue for more optimizations ideas.
• Fixed several bugs related to HTTP DIGEST authentication.
• Fixed support of conditional processing for non-GET methods and allowed entity headers to be returned if conditions were not matched.
• “onSent” and “onResponse” callbacks now also work with synchronous HTTP connectors (Net and HttpClient extensions).
• XStream annotations are now detected and allow customization of XML and JSON representation from the representation beans.
• ServletUtils class introduced in RC2 was moved into the org.restlet.ext.servlet package. It also the easy retrieval of Servlet request and response objects from the Restlet equivalents.

Direct contributors

• Antonio Fiestas
• Bruno Harbulot
• Carsten Lohmann
• Dan Simpson
• Graham Smith
• Leigh Klotz
• Mark Drew

Thanks to all others who helped us in various ways!

Additional resources

Changes log:
http://www.restlet.org/documentation/2.0/jse/changes

Download links:
http://www.restlet.org/downloads/testing

Maven repositories:
http://maven.restlet.org is updated on the 1st and 15th of each month
http://maven.noelios.com is updated daily with new artifacts (access reserved to subscribers)

In addition, Restlet Framework version 1.1.9 was released, fixing two bugs (setting of custom server name and ISO latin 1 parsing for HTTP BASIC credentials).

Main changes

• SSL keystores configuration was adjusted for simplicity purpose
• User and Role classes now implement java.security.Principal interface. The UserPrincipal and RolePrincipal classes were removed from the JAAS extension and JaasUtils#createSubject() now also adds the ClientInfo#principals entries.
• A ServletUtils class was added to the Servlet extension with two methods to easily retrieve the Servlet request/response.
• 13 bugs were fixed including one regression with cookie headers handling, WADL/HTML generation, ResourceException not correctly propagating the status code, local conversions between representations and objects, or GWT serialization issues with nested generic types and arrays.
• Simple Framework libary was updated to version 4.1.20, fixing an SSL issue reported by Restlet users

Direct contributors

• Bruno Harbulot
• Carsten Lohmann
• Kelly McLaughlin
• Rob Heittman
• Sirthias
• Tal Liron
• Thomas Conté
• Valdis Rigdon

Thanks to all others who helped us in various ways!

Additional resources

Changes log:
http://www.restlet.org/documentation/2.0/jse/changes

Download links:
http://www.restlet.org/downloads/testing

Maven repositories:
http://maven.restlet.org is updated on the 1st and 15th of each month
http://maven.noelios.com is updated daily with new artifacts (access reserved to subscribers)

Since the release of our Restlet extension for ADO.NET Data Services in September 2009, many changes happened on this front. Microsoft has been busy enhancing their technology, splitting it into an open specification for the REST API called OData, for Open Data Protocol, and using WCF Data Services for the server-side framework. This article gives an overview of the technology, and this page the full specifications of the protocol.

The OData protocol has also been embraced by IBM in its Java-based WebSphere eXtreme Scale product and Microsoft has leveraged it in several of its products like Excel PowerPivot, SharePoint Server, Windows Azure Table Storage and SQL Server Reporting. Other recent initiatives are the project code-named “Dallas“, which offers a market place for data services with full support for access control and billing, and the OData visualizer part of Visual Studio 2010.

In addition, public OData services are starting to pop-up, like the one to access Netflix’s media catalog. Microsoft has been providing examples via the OGDI initiative and for the MIX’10 conference. Here is a longer list of producers.

Enhanced Restlet extension

While preparing our recent Restlet Framework 2.0 RC1 release, we enhanced our Restlet extension for OData, moving it from the “org.restlet.ext.dataservices” to the “org.restlet.ext.odata” package and adding support for those advanced features:

• Projections, similar to database views
• Transparent server-side paging
• Blobs, to expose media resources
• Row counts retrieval
• Customizable Atom feeds
• Version headers
• Operations, to expose stored procedures

The extension is also available on the Restlet edition for Android, allowing you to directly access OData services, for example hosted on Azure cloud computing platform, from a smart phone.

The diagram above illustrates how useful the Restlet extension for OData is becoming, as a high-level client for data services powered by a growing number of server-side technologies. For explanation on how to use this extension, read the Restlet user guide page for the extension as well as a detailed tutorial.

Towards standardization

All those initiatives have caught attention with articles and posts like:

• InfoQ – Microsoft Proposes OData as de facto Web Data Protocol
• InfoQ – Is OData The Ubiquitous Language For Application Collaboration?
• Jon Udell – OData for collaborative sense-making
• Jon Udell – Producing and consuming OData feeds
• Stephen Forte – The Open Data Protocol

An interesting thing to watch going forward is how this technology will be compared with Google Data Protocol (GData) alternative. In his OData Q&A page, Microsoft hopes for a collaboration with Google on an official set of extension to the Atom suite of standards.

Yahoo! has also worked on a similar technology called DataRSS, and finally the W3C is pushing the Linked Data, an application of the Semantic Web, as a way to transform the Web of documents into a Web of data, with technologies like RDF and SPARQL.

Updates:

• Thomas Conté (Microsoft) – Consommer des services OData en Java avec Restlet (French)
• Jean-Christophe Cimetière (Microsoft) – OData interoperability with .NET, Java, PHP, iPhone and more

We can now enter the stabilization phase, fixing as many issues as possible to reach the  level of quality for production applications. We encourage all Restlet developers to review the list of open issues and contribute by entering new issues, adding comments to help fixing them and even better to contribute patches!

Another effort has been started to update the user guide to match the API changes and new features in version 2.0. For example, the table of contents has been simplified, changes since version 1.1 have been summarized and an extensions matrix has been added. This is a collaborative effort and new authors are also encouraged to participate.

Main changes

• Various cleanings to the Restlet API. Added Expectation and RecipientInfo classes in org.restlet.data to support the HTTP Expect and Via headers.
• Refactoring and cleaning of all the XML extensions. The dependency from JAXB and JiBX extensions to org.restlet.ext.xml has been removed.
• Enhanced the CLAP connector to support a default authority (“class”) for shorter URIs (ex: “clap:///org/restlet/Uniform.class”). Added LocalReference#createClapReference(int, Package) and createClapReference(Package) methods to help building shorter CLAP URIs.
• The Data Services extension for Microsoft ADO.NET/WCF has been renamed to OData as the protocol specification has recently been opened up. Added support for new features such as projections, blobs, server-side paging, row counts, customizable feeds or version headers. See related blog post.
• 20 bugs have been fixed including one preventing the compilation of annotated interfaces in the GWT edition and another annoying one eating the query part of URIs with the default connector.
• All the library dependencies have been updated, for example Spring to 3.0.1, Jackson to 1.4.3, Jettison to 1.2, Apache Lucene to 2.9 or Apache Velocity to 1.6.3.

Direct contributors

• Andreas Schneider
• Bryan Hunt
• Carsten Lohmann
• Daniel Truemper
• Fabian Mandelbaum
• Harald Pehl
• John Wismar
• Laszlo Megyer
• Laurent Rustuel
• Martin Kubincanek
• Masaki Sudo
• Nicolas Rinaudo
• Nirav Shah
• Rhett Sutphin
• Rickard Oberg
• Tal Liron
• Tim Peierls
• Xavier Mehaut
• Zsolt Czinkos

Thanks to all others who helped us in various ways!

Additional resources

Changes log:
http://www.restlet.org/documentation/2.0/jse/changes

Download links:
http://www.restlet.org/downloads/testing

Maven repositories:
http://maven.restlet.org is updated on the 1st and 15th of each month
http://maven.noelios.com is updated daily with new artifacts (access reserved to subscribers)

To celebrate this new release, Manning is having the Restlet in Action book as their Deal of the Day for Jan 29, 2010. The deal is the ebook in early access for just  $10, using code dotd0129!

Main changes

• Asynchronous call handling is now available on both on the server-side and the client-side. The callback mechanism used was inspired from GWT and is fully consistent with our Restlet edition for GWT, ensuring a greater portability.
• Replaced the default/internal HTTP connectors with new ones based on a more flexible design. They now support all advanced HTTP features such as persistent connections and pipelining on both client and server side. They are for now the only connectors, beside the GWT edition, supporting the new asynchronous handling capabilities of the Restlet API.
• Requests and responses can now be aborted, useful to save bandwidth where undesired calls are handled.
• Security realms now have a lifecycle allowing the initialization from a relational database, a file or a LDAP directory.
• Component services are now extensible, allowing you to add your own to the chain.
• The Simple, Jetty and Netty extensions were removed from the Java EE edition for size purpose. Download the Java SE edition of the Restlet Framework if you need them.
• New Jackson extension added, offering a nice alternative to the existing XStream extension for JSON object serialization (based on Jettison).
• Converters were added for all relevant Restlet extensions, allowing usage of high-level classes in annotated Restlet interfaces for example.
• The WCF Data Services extension (previously called ADO.NET Data Services) is now also available in the Android edition.
• GWT object serialization support, based on annotated Restlet interfaces was also added for the GWT edition, leveraging GWT’s deferred binding mechanism and GWT-RPC serialization format! See this related post for details.
• Significantly improved the ability to generate dynamic client proxies from annotated Restlet interfaces, while giving them access to the underlying ClientResource instance via a ClientProxy interface automatically implemented, like for the GWT edition. Proxies for child or parent resource can also easily be obtained, reusing the current resource like a prototype resource!
• The component XML configuration has been extended to support all existing properties and features available in the Java API.

Direct contributors

• Ben R. Vesco
• Bruno Harbulot
• Carsten Lohmann
• Cedric Hurst
• David Fogel
• Fabian Mandelbaum
• Iestyn Evans
• Jeff Ramsdale
• John Logdson
• Jonathan Hall
• Laurent Rustuel
• Remi Dewitte
• Sanjay Acharya
• Tal Liron
• Taylor Cowan
• Tim Peierls

Thanks to all others who helped us in various ways!

Additonal resources

Changes log:
http://www.restlet.org/documentation/2.0/jse/changes

Download links:
http://www.restlet.org/downloads/testing

Maven repositories:
http://maven.restlet.org is updated on the 1st and 15th of each month
http://maven.noelios.com is updated daily with new artifacts (access reserved to subscribers)

• Google Web Toolkit (GWT) for AJAX applications deployed in desktop browsers, without any plugin required
• Google App Engine (GAE/J) for deployment on Google’s cloud computing infrastructure
• Android for deployment on compatible smartphones
• Java SE for standalone deployments in regular Java Virtual Machines
• Java EE for deployment in Servlet engines

Each edition is offering the same Restlet Framework, with restrictions and adjustments based on the target environment. For example, the GWT edition only supports the client-side usage of Restlet, while the GAE edition only provides compatible extensions and ensures that we don’t break the security sandbox or use unsupported JRE classes.

As a result, you can easily develop a unified Restlet application with a server-side deployed in GAE, a client version available for Android smartphones and another available for desktop browsers with GWT, fully leveraging the most innovative technologies available from Google for Java developers.

You might wonder what exact value does Restlet brings in the middle of those technologies? The Restlet Framework is all about REST, supporting advanced HTTP features such as content negotiation, caching and conditional processing, allowing for the same URI-addressable resource to expose various representations. Each representation renders the same information in  various languages or formats such as JSON, XML or anything else that makes sense for your clients such as binary pictures.

Supporting content negotiation allows your Restlet cloud server to expose the same resources to all its clients, including an Android smartphone client, a GWT desktop client, a Flex client, a programmatic Java SE robot or a basic HTML browser. One Java API and one unified code base gets you covered in all those scenarios, even if you need to serve static files: a Restlet Application truly merges the notion of Web Site, Web App and Web Service!

So, using Restlet as a cloud server gets you much further than a regular Servlet application. Usually, you would use GWT-RPC to communicate between your GWT client and your GAE back-end, and the low-level HTTP client provided by Android to communicate with your GAE custom Servlets. Obviously, the result wouldn’t be very RESTful as GWT-RPC is introducing some strong coupling. You could use the low-level HTTP client provided by GWT as well, but then you would loose the big benefit of using Java proxies in GWT, with transparent serialization of parameters and result object.

This is where the Restlet Framework comes to rescue! For GWT, we provide both a high-level HTTP client, removing the need to manually parse and format HTTP headers thanks to its Restlet API but also a proxy generation mechanism based on GWT deferred binding very similar to GWT-RPC but truly RESTful! Migration of existing GWT-RPC code is straightforward as we also support GWT-RPC AsyncCallback interface in addition to our equivalent Result interface. For our serialization format, we reused the one of GWT-RPC, a special JSON variant, therefore it is fully featured and as robust as GWT-RPC ! In your Restlet cloud server, you just need to add our server-side GWT extension to transparently support this serialization format, thanks to content negotiation.

If you are a Google fan, you should be happily developing with the recent GWT 2.0, Android 2.0 and GAE 1.3.0 releases and the RESTful solution described above should gives you a big smile and to get started, we have written a complete tutorial, with full source code, illustrating a unified Restlet application for GAE, GWT and Android.

But even in this scenario, you wouldn’t be restricted to Google technologies, you could chose to support alternative clients such as regular HTML browsers, Flex or Silverlight clients, or any other HTTP client. On the server-side, you could take the same Restlet application and deploy it locally, or on Amazon EC2 or Microsoft Azure, thanks to our Restlet editions for Java SE and Java EE which can be installed on those major cloud platforms!

In the end, the Restlet Framework offers you, for free, the first comprehensive RESTful middleware for Google technologies and beyond! As a last word, I would like to thank again my friend Didier Girard, for sharing his insights that led us to this post (and a lot of work!)

As a result, those products typically offer a mechanism to programmatically interact with their CMS through the Web, by providing a Web Service API. Ideally, those APIs are designed RESTfully such as Nuxeo ECM which leveraged Restlet. This approach was explained in more depth in a CMSWire article covering Alfresco’s RESTful approach and mentioning Restlet has a good candidate for lighter and more RESTful Web frameworks.

Jalios JCMS, a commercial ECM product, also leverages Restlet for their RESTful OpenAPI. Another nice example of a REST API based on Restlet was recently provided by NeoDoc in their Calenco product, a CMS focusing on the collaborative edition of documents such as strategic business documents, technical documentation, user guides, quality manuals or security procedures.

While each of those REST APIs supports the special features of their related CMS, users might prefer for some scenarios to use a more generic REST API, not tightened to a particular vendor or project. This is the purpose of the Content Management Interoperability Services (CMIS) standardization effort. Version 1.0 is currently is final review stages, and seems to be gaining a lot of traction.

However, Roy T. Fielding expressed some critics on the initial draft in this blog post, pointing to its lack of RESTfulness and the fact that it was too focused on document management instead of content management as its name implies. It seems that the RESTfulness concerns were mostly addressed, but not the one of the scope of the specification . Note that Nuxeo already supports CMIS and that Jalios has planned its support as well.

Finally, there is a new trend in CMS called Web Content Management (WCM), focusing on the online edition of Web documents and Web sites in general. This family includes Wiki software like the powerful and open source XWiki which also leverages Restlet for their REST API.

Another illustration of this trend leading to more and more convergence of CMS towards the Web are major online services like Google Docs and Microsoft OfficeLive, enabling the collaborative edition of enterprise content, progressively blurring the line with regular Web content. As a final illustration of how Restlet can successfully support the development of WCM systems, I recommend you to have a look at GoGoEgo, a very promising open source RESTful WCM recently launched by Solertium.

Their solution not only provides a REST API, but is fully designed as a RESTful Web application, with an administrative front-end based on GWT and the ability to be hosted on the cloud with Google AppEngine. Solertium is also a strong supporter and contributor to the Restlet project, as illustrated in this passionate post from their CTO about friendly frameworks!

Update : Mentionned CMIS implementors. Adjusted wording regarding Roy & CMIS based on feed-back from Benoît Dissert of Jalios