Skip navigation

This is Volume 36 of This week in REST, for Mar 27 2011 – May 30 2011. For more information on this blog see this post. If I missed an interesting blog post, discussion or paper – just e-mail me the links, tweet or leave a comment on the latest blog post. Thanks! P.S. sorry for being away for 2 months… lot’s of stuff happening at work so blogging got pushed down the priority stack.

Around the Web

A REST wankery question – “Given that, would you use URIs like /photos and /photos/{id} (as a photo list and photo detail resource, respectively)? … It seems like URIs like /people/{my-uid}/photos and /people/{my-uid}/photos/{photo-id} are more “pure.” But now that’s weird because only one single user ever has access to a given URI (e.g only user #7 gets to access the entire space under /people/7).” (by Jacob Kaplan-Moss)

Identifying Application State – W3C Working Draft: Proposed TAG Finding  “This document explores the issues that arise from the use of fragment identifiers to identify application state and attempts to define best practices.” (by T.V. Raman, Ashok Malhotra)

Web APIs: Don’t be a victim of your success – “As developers, we are used to dealing with unforeseen problems, we just fix them and redeploy.  However, APIs are different beasts, because the applications that consume the API are often not written by an external developer.  Making significant changes is likely to impact clients, and breaking clients not only annoys the client developers but also the users of those clients.  It’s just not good for business.This article discusses approaches you can take upfront, that will minimize that chances of breaking clients as your API evolves to meet the crushing demands of success ” (by Darrel Miller)

evolvable systems – “How can we design and implement distributed network solutions that remain stable and flexible over time? … my assertion is that one successful approach invovles a combintion of accepting and embracing some realites of dist-net architecture, isolating the key transient aspect of the environment, and focusing most of your creative eneregies on expressing the vital problem domain information in a flexible and evolvable way.” (by Mike Amundsen)

Scanning data with HTTP – “As part of my series on SCADA and REST I’ll talk in this article a little about doing telemetry with REST. There are a couple of approaches, and most SCADA protocols accidentally incorporate at least some elements of REST theory. I’ll take a very web-focused approach and talk about how HTTP can be used directly for telemetry purposes.” (by Benjamin Carlyle)

Why and How You Should Write REST-Centric Applications – “Ever since Twitter built their “New Twitter” UI on top of their existing API, the idea of incorporating the very same philosophy into my own applications resonated with me. I decided to move forward with the same approach and my team and I been doing so since September. For those of you that have not taken this route, what I’d like to do is share some of the reasons why you may want to, and some advice on how to make it relatively painless. ” (by Michael Woloszynowicz)

SOA in 2011 Panel – “Many companies embarked on servicizing their software implementations and some achieved great success, while others failed. SOA was on the top of analysts’ reports, then was proclaimed dead and then reborn under slightly different names – REST, cloud computing, etc. There are literary thousands of SOA books and articles covering many aspects of SOA from architectural design to nitty-gritty implementation details. In this virtual panel, InfoQ talks to 5 SOA experts about the significance of SOA, its relationships with other architectural styles, best technologies and approaches used for successful implementations of SOA solutions and SOA future.”

How do you measure the RESTful-ness of an application? – “Over the past few years it would be hard to ignore the rise in popularity for using RESTful approaches to building enterprise applications. Now we seem to have moved beyond the REST vs WS-* debates, or whether or not REST and SOA are complimentary, to discussions around the maturity of REST-based implementations. Unfortunately it seems that even this could be an active area of confusion, debate and disagreement. When discussing maturity and REST in the same sentence, some individuals refer to the Richardson Maturity Model as the right approach to measure against. For instance, in his recent article Martin Fowler discusses the various levels in the model”

List of ways HTML can download a resource – “Recently two different projects required compiling a list of ways to trigger a download through HTML: Resource Timing and Preload Scanner optimization.There’s no centralized list in the WebKit source nor did a web search turn one up. So in hopes it may be useful to others, here’s what I was able to come up with. Please let me know what I forgot (note that ways to download through CSS, JS, SVG and plugins are intentionally omitted).” (by Tony Gentilcore)

Information Resources and Web Metadata – “This note considers the semantics of metadata in which the subject of the metadata (the “data”) is specified using a URI that may be dereferenced on the Web. This situation is complicated in that agents might obtain different information on different dereference operations, raising the question of what metadata is true or not of the metadata subject.It is proposed that the practical purpose of the “information resource” abstraction in web architecture is mainly to supply suitable subjects for this kind of metadata. Relating information resources to metadata in this way makes concrete the value proposition for the rule that a URI should name the information resource related to dereference of that URI. It is hoped that this analysis will be of use in future work aimed at strengthening or modifying consensus around this rule. ” (by Jonathan A. Rees)

Links Don’t Open Apps – “The realization that links don’t open apps has triggered for me a renewed appreciation of the power of hyperlinks. When people talk about the differences between native apps and mobile web, they usually talk about difference like performance, cross platform development, and other technical factors.” (by Jason Grigsby)

Mature REST In Six Lines! – “Like Subbu, I also have been sitting on a blog post about the Richardson Maturity Model. I have different reasons for feeling uncomfortable with this Model, however.The following came out of a discussion on an internal list at ThoughtWorks, where a number of people were talking about how they aspired to reach the “Holy Grail” of REST Level 3, and still thought they were basically “doing REST” by addressing most of the uniform interface.But, as indeed pointed out in that article, REST is only at Level 3.However, fortunately, you can jump right to Level 3 without much effort.” (by Duncan Cragg)

Webmachine and RESTful Web Frameworks with Justin Sheehy – (video) “Justin Sheehy discusses the benefits of RESTful web frameworks and how these apply to the Webmachine toolkit. He also talks about security, debugging and the future of web frameworks and HTTP.”

Using DNS for REST Web Service Discovery – “The use of the REST architectural style is steadily gaining momentum for both public facing Web services and enterprise integration. However, one aspect of a service oriented architecture does not yet receive sufficient attention: Service Discovery. In this article, I will describe how existing Web technology can be leveraged to enable Service Discovery for RESTful Web services.” (by Jan Algermissen)

Measuring REST – “Don’t follow models like Richardson’s Maturity Model to decide whether your app is RESTful or not.Why not? The reason is quite simple. We build software to do something of value while accounting for some quality attributes (or “ilities”). In the case of RESTful apps, how you prioritize a given set of quality attributes can help you choose the right set of constraints. Period. ” (by Subbu Allamaraju)

Atom Content Negotiation – “let’s assume you have a collection of items that is exposed via feeds and managed in whatever back-end storage works well for you. you want to be a good web citizen and publish it as HTML, XML, JSON, and RDF. you also want to be a good web service citizen and publish any updates via feeds, so that consumers are notified whenever the collection changes. what is the best web pattern to do that? i am wondering what the more popular approach is, and why. i am also wondering whether it might be worth the effort to have a small extension that would make this more reliable in the sense that there would be a link relation for interlinking feeds that carry the same content, but using different content types.” (by Erik Wilde)

My PUT Requests Bug Me – “So here I am, writing documentation for some new GitHub API sweetness, when something strikes me. Why are we using PUT requests for updates? Should it bug me that my API uses the PUT verb?” (by )

Events

W3C Workshop on Identity in the Browser – Papers from the W3C Workshop on Identity in the Browser, 24/25th May 2011, Mountain View (USA).

Interesting tweets

@AndrewWahbe – “Henry S. Thompson: “architecture of the internet is concrete while the architecture of the web is abstract” #IETF80

@AndrewWahbe – “Rosenberg: web model is becoming the same (proprietary protocol) with a mechanism for distributing software #IETF80

@wmartinez – “Good faces on Interoperability and Modifiability for REST. Sad face for Performance and Reliability. Merson. #soacloud

@mamund – “RT @dret: “a need for Uniform Data?http://bit.ly/jFzT9h (by @webr3) ; no, a uniform interface & media types work just fine.” #REST +1″

@algermissen – “From chat with @mamund:Media types should specify which kindsof links refer to resources with bookmarkable URIs. Or is there a way to guess?”

@dret – “really hope for #www2012 to be less about mining web content, and more about web architecture and web as a platform. architecture matters.”

@fielding – “@mnot I have a much better test page for deciding whether a site is truly RESTful or not: http://s.apache.org/FKu

@WSREST2011 – “”the state sandwich: application state machine, hypermedia state machine, HTTP state machine, media state machine.” @svrc #wsrest2011

@WSREST2011 – “look out for “Behave”, to be released by @svrc in may 2011. #wsrest2011

@WSREST2011 – “”main difference between programs an agents: agents act in an environment, agents are goal-oriented and autonomous.” @svrc #wsrest2011

Advertisements

This is Volume 35 of This week in REST, for Mar 7 2011 – Mar 26 2011. For more information on this blog see this post. If I missed an interesting blog post, discussion or paper – just e-mail me the links, tweet or leave a comment on the latest blog post. Thanks!

Around the Web

Is it RESTful? – “This site helps people to figure out if their Web site and APIs are RESTful, by interactively interrogating them and applying a suite of cloud-based analytics. Or, it gives a completely random answer.”

Nobody uses the term “web services” anymore. – “Apropos revising RESTful Web Services, I have a question for you. When I started talking with people as part of my job search, I noticed that nobody uses the term “web services” anymore. Everyone talks about “APIs”.”

Trends in Web Applications and the Implications on Standardization – “Advancements in the design of web browsers have introduced   fundamental changes to the architecture of application protocols.   The widespread availability and growing sophistication of JavaScript   interpreters in browsers enables web servers to push to browsers all   of the application logic required to implement a client-server   protocol.  Consequently, many client-server applications that once   required an installed client on a host computer now can rely simply   on a modern browser to act as a client for the purposes of a   particular application.”

IETF technical plenary: the end of application protocols – “As described, the session suggests a failure to recognize at least two architectural issues. One is that it mandates full-time connectivity.  The other is that protocolsthat it says are no longer needed are in fact still needed in some form, albeitas a layer above HTTP, rather than TCP.”

AJAX is the new NAT – “What we need to do is acknowledge that AJAX has happened. The Web hasn’t been “hypertext” for a long time now.”

BPM with REST – “Cesare Pautasso discusses the conceptual relationship between business processes and stateful RESTful services, showing how BPM can be used to design and implement hypermedia-based services.”

Give me a REST, I just want to get my Message across – “When you start building applications on top of WebSockets (and degrading) you also start to think about different architectures. WebSockets gives us a rich, fast, bi-directional pipe between the client and server. Whether you are a Socket.IO lover with Node++, or an Enterprise sort on Kaazing, you can start to deal with a very simple messaging API (that degrades).”

Resource Identification and Query Parameters in URIs – “An interesting topic came up at QCon London: What identifies a resource? One view is that resources in REST are identified without considering the query parameters in the URI. In most RESTafarians’ view, none of the characters in the URI should have special meaning. But even if one happens to agree with this, it’s still interesting to find out what the specs actually say.”

Microsoft gets serious about Http – Presentation by Darrel Miller.

state transitions: simple and complex – “it’s easy to get bogged down in what state transitions “are”, how they “work”, and their role in hypermedia and the Web in general. i’m going to skip over all that here[grin]. instead, i want to focus on some of the concrete details of state transitions for hypermedia and why i think identifying them is critical for building robust distributed applications.”

Repurposing the Hash Sign for the New Web – “The Hash sign (#) in a URI was originally used to introduce a static “fragment identifier”, but recently it is being used in many more complex ways as it is set by and interpreted by JavaScript in Web applications. Fragment identifiers are used to provide several different kinds of parameters to the client-side application, such as the actual URI of a video to be played to a video player, or the position and zoom to a map. Unlike search parameters preceded by “?”, the characters in the URI bar after the “#” can be changed without causing the page to be reloaded. Applications and toolkits using fragment identifiers in this way often go to some effort to maintain a history and make sure the back button works as expected. Accessibility and search can, however, be compromised because without running JavaScript, the URI has no meaning. Such uses of the “fragment identifier” have interesting and different properties, and differs from the way it is currently described in specs. This document explores the issues that arise from these new uses of fragment identifiers, and attempts to define best practices.”

Documents in applications – “It has become fashionable to divide Web resources into two broad categories: each resource is either a document, rendered primarily in HTML, or an AJAX-style  Web application that uses Javascript to facilitate very dynamic interaction, navigation and information retrieval.  My purpose here is to argue that we need to be more careful, that many AJAX applications in fact provide access to documents after all, and that the Web would be much more robust if we took some care to identify and access those documents using the same sorts of URIs that we use for other Web documents.”

Managing Relationships between Resources with URIs – “The big benefit of systems based on addressible resources is that the resources are identified by portable URIs. The big payoff is that, unlike database primary keys, the identifiers are usable in a much broader context than just that system itself. In most cases, those URIs are, in fact, URLs. But since they are addressable, we’re not limited by things like PK values or names that only our system understands. We can share those identifiers between disparate systems.”

REST, Hypermedia, and Query Strings – “Now, I agree totally that the path part of the URI — that is, everything in front of the first “?” or “#” should be treated as an immutable, opaque string. That’s just saying that the server controls that part, and can change it at a moment’s notice. The client must be decoupled from the path of the URI. But the query string part of the URI is not so clear.”

Hash URIs – “Having looked at the advantages and disadvantages, I would echo what seems to be the general sentiment around traditional server-based websites that use hash-bang URIs: pages that give different content should have different base URIs, not just different fragment identifiers. In particular, if you’re serving large amounts of document-oriented content through hash-bang URIs, consider swapping things around and having hashless URIs for the content that then transclude in the large headers, footers and side bars that form the static part of your site.”

Events

WS-REST 2011 – Preliminary proceedings for the WS-REST workshop have been published online.

This is Volume 34 of This week in REST, for Feb 9 2011 – Mar 6 2011. For more information on this blog see this post. If I missed an interesting blog post, discussion or paper – just e-mail me the links, tweet or leave a comment on the latest blog post. Thanks!

Around the Web

Long Bets: PREDICTION 601 – “The original URL for this prediction (www.longbets.org/601) will no longer be available in eleven years. “Cool URIs don’t change” wrote Tim Berners-Lee in 01999, but link rot is the entropy of the web. The probability of a web document surviving in its original location decreases greatly over time. I suspect that even a relatively short time period (eleven years) is too long for a resource to survive.I would love to proven wrong.” (by Jeremy Keith)

Principles of the Same-Origin Policy – “The security model of the web platform has evolved over time to meet   the needs of new applications and to correct earlier mistakes.   Although web security has evolved largely organically, the security   model has converged towards a handful of key concepts.  This document   presents those concepts and provides advice to designers of new   pieces of the web platform.” (by Adam Barth)

Design Considerations for Protocol Extensions – “This document discusses issues related to the extensibility of Internet protocols, with a focus on the architectural design considerations involved.  Case study examples are included. It is intended to assist designers of both base protocols and extensions.” (by B. Carpenter, B. Aboba and S. Cheshire)

More on PUT Idempotency – “One of those conversations was started with a reference to a really good blog post from Alex Scordellis addressing the question of how complete representations sent in a PUT need to be. What exactly does the client need to include in the representation that they PUT – all properties? what about hyperlinks? A simple answer might be that they need to provide “everything”, but this simple answer is just not satisfactory.” (by Cornelia Davis)

Headless Foxes – “If a server is just a browser instance and the client is a browser instance then this completely changes how a web developer can think about development and debugging. What if Firebug was a server itself? You made AJAX calls to it, and it ran the “server-side” JavaScript in your browser, the same as it would on a live server. No longer would you be tied to the infrastructure of your live environment.”

my boundary issues w/ hypermedia – “as a result of my efforts to refresh my concept of hypermedia and it’s role in distributed network applications, i’ve come to view the messages passed between client and server as containing several distinct sets of information. these are: Protocol information … Domain information … State information …” (by Mike Amundsen)

i have an experiment; will you help? – “in this experiment multiple parties must build client and/or server applications to match a spec; all w/o seeing each other’s work. IOW, there is no “sample” running somewhere. in addition, the “application” uses XHTML as the base media type (sorry, no custom media type this time[grin]). finally, the only instructions for this experiment are found in a single document that contains the “semantic profile” of the target web application expressed via selected XHTML attributes (@class, @id, @name, and @rel) along with “valid values” for these attributes, descriptions of how they are used in representations, and “what these values mean.”” (by Mike Amundsen)

Principles and Patterns of Organizing Systems – New (?) course at Berkeley with slides and material being posted as the semester progresses: “The concept of an organizing system complements this categorical view with a dimensional perspective that sees these categories as sets of design patterns that reflect typical answers to questions about what is being organized, why, when, how much, who is doing the organizing, and how services are provided to interact with the organizing system. These dimensions frame trade-offs and constraints about the content, policies, and implementation of organizing systems. The primary goal of this course is to use these design dimensions to better understand traditional design patterns and their consequences, and to identify useful new ones.” (by Erik Wilde and Robert J. Glushko)

RESTful SOA in the Real World – (video) “Sastry Malladi presents different ways used by the industry to implement a RESTful SOA, detailing how eBay did it in order to achieve performance, and what lessons can be taken from that.” (by Sastry Malladi)

What is REST, Anyway? – “…so I’ve been spending some time reading more about REST, refining my thinking, and opinionizing a lot on this blog.I finally came to the conclusion that REST is not what a lot of people treat it as. It’s not a standard you can write a strict spec for, and then apply it to projects and declare “Yay!” or “Nay!” People do that, and that practice sinks a lot of projects, because it’s a silly practice.”

REST in the design, use, and documentation of Web APIs – Slide deck for intro-level REST presentation at DHapi (by Peter Keane)

This year in #rest on Freenode – Word cloud of chats from the #rest channel on Freenode. (by Kevin Burns Jr)

Calculated vs. Shipped URIs – “I wonder about the effenciencies, though. CPU is cheap and fast, bandwidth is slow and (kind of) expensive. So publishing a URI spec out-of-band and letting the client construct the actual URI with string concatenation consumes very little runtime resources. But shipping big documents loaded with hyperlinks, millions and millions of times, is going to be expensive.”

Client-driven APIs – “I lot of the REST conversations I’ve seen get tangled up because they are trying to constrain their Resource definitions too tightly, and end up restricting what the client can get at, making the client make lots of calls to get what they could get at once. Or they go the other extreme, and make Resource definition so incredibly broad that every Resource in the system meets every need that we could possibly anticipate from the client, making every response huge, bloated documents that take a long time to code, maintain, and support the bandwidth for.”

Designing RESTful Domain Application Protocols – Slide deck for presentation at JFokus: “REST is ready for the enterprise. Imagine an information platform that is open and available to systems throughout the enterprise estate. A platform that eschews integration in favour of composition, connected data over siloed databases. A networked data structure with the power to implement valuable business behaviours: a distributed, hypermedia-driven application platform. Challenging the notion that REST is suitable only for simple CRUD-based data services, in this session I show how to design and implement RESTful domain application protocols for complex business processes. With a detailed example, I show how to: – Model business processes as domain application protocols – Implement them in terms of resource lifecycles – Advertise and execute them using HTTP idioms, media types and link relation values” (by Ian Robinson)

Dog or Tail: REST or Hypermedia? – “My personal opinion is that as the tools to support hypermedia evolve, REST as we know it today is going to become a side discussion. That the principles of REST will be just small part of the discussion on how we deliver hypermedia. A few examples of why I think that are: …”

HTTP Headers – “This is a continuation of work started by Brough Davis as part of his software security project for his Masters in Information Security Engineering. The main goal of this project is to find how many sites use security relevant headers, like for example the X-XSS-Protection or X-Frame-Options headers.”

Web Apps and Web Sites – “What’s the real tradeoff in the hashbang case? The tradeoff here is between usability of two classes of clients – one that does not support Javascript and the other that supports. That’s a reasonable tradeoff! Twitter chose to not render http://twitter.com for non-Javascript browsers. Perhaps they made that by choice by looking at the proportion of users that use non-Javascript browsers.” (by Subbu Allamaraju)

A simple overview of httpRange-14 – “Complicated issue eh? it’s certainly consumed a great deal of my time for over a year.So, here’s a simple-ish summary of the problem – disclaimer, all IMHO of course…” + The simplest view possible of httpRange-14. by the same author.

Minutes from the March 03 telcon of W3C TAG + Minutes from the 8-10 February 2011 TAG F2F Meeting

Events

WS-REST 2011 – The list of accepted papers for WS-REST 2011 has been published. However, not all reviewers are happy with this year’s submissions. The workshop keynote will be given by Stu Charlton, you can see his sneak peek for the talk here.

ComposableWeb 2011 – “the 3rd International Workshop on Lightweight Integration on the Web (ComposableWeb 2011) will be held in conjunction with the 11th International Conference on Web Engineering (ICWE 2011) in Paphos, Cyprus, from June 20-24, 2011.”

WEWST 2011 – “The Workshop on Enhanced Web Service Technologies (WEWST), collocated with the European Conference on Web Services (ECOWS), is the premier workshop for academic and industrial communities to discuss innovative ideas and research contributions advancing the state-of-the-art in Web service technologies.” Will be held on September 14, 2011, Lugano, Switzerland.

Discussion groups

Django REST framework – Critical feedback wanted. – Discussion on new Python REST framework for Django: “Django REST framework is a lightweight REST framework for Django, that aims to make it easy to build well-connected, self-describing RESTful Web APIs.”

Cross-Origin Resource Embedding Restrictions – Discussion about an idea and specification for “…defining a way for resources to declare they are unavailable within an embedding context.”

Review of TAG issues related to “URI meaning” (long) – Overview of W3C TAG issues related to the problem of “URI meaning”.

Conversation about “Web Applications Architecture” additional background for TAG discussion

Loose coupling – a RESTful myth? – “It is often stated, that RESTful services decouples client and server, as e.g. stated here [1]:”Coupling between client and server is removed, server owners need not know about client particularities to evolve the servers without breaking clients.”But i think, the most server changes will break even the RESTfuls´ clients.”

Link header is representation metadata? – “Sorry but I need to come back to this one, can I get a definitive answer (please :)) on whether the Link header is representation metadata (like Content-Type), or not?”

Software frameworks

CRest – “CRest (Client Representational State Transfer or Client REST) is a lightweight framework aiming to simplify the integration of external REST services into java applications, somewhat in the way most of the current SOAP WSDL oriented client framework works.While SOAP is a protocol, based on a service descriptor format (WSDL) that can be used to automatically generate the client stubs, REST isn’t, and REST service implementation varies from one provider to another.CRest allows the developer to only focus on the essential aspects of the integration of a REST service.”

Interesting tweets

@kriszyp – “HTTP response of the future when you visit a site? https://gist.github.com/853195

@AndrewWahbe – “Hash Bang URLs are a symptom, the problem is that nobody is trying to extend markup to do simple AJAXy things declaratively”

@jerenkrantz – “With due respect to @timbray & @fielding, #! in URLs indicate where REST falls down: computations – rather than documents – are exchanged.”

@fielding – “@jerenkrantz Making it easy for Web developers to create fragile, unreliable, and unsharable Web experiences is not a goal of REST.”

@mikekelly85 – “#REST is about agreeing on the best way for machines to facilitate human interaction and stay out of the way”

@dret – “finding it interesting that one of the most universal human actions (going to) has become a synonym for HTTP GET.#REST #uniforminterface

@svrc – “Trying to craft a RESTful service discovery approach with the XRD/host-meta/LRDD stuff. Finally the last nails in the UDDI coffin.”

@dret – “don’t fall prey to the dark side of where the functions lurk. focus on resources you must, and links will guide your path.#REST

@aslak_hellesoy – “WebSockets are throwing the baby out with the bathwater. Server Sent Events/EventSource and REST seems a much better stack.”

@dret – “if i can link to and reuse resources from your server, you’ve built a web app. otherwise, you’ve just built an app using browser APIs.”

@dret – “discovered that #REST can be nicely illustrated with menus, restaurants, orders, food courts, pending orders, special requests, and: food.”

@mamund – “RT @iansrobinson: @dret “… I want some term for the specialisation that helps us get things done.” <- application semantics?”

@jar346 – “”representation” is hateful not because I hate people who use it, but because its multiple definitions make you fight one another!”

@iansrobinson – “@dret Resources don’t come into it, cause I don’t think resource types are useful; resources are just sinks and sources for representations”

@iansrobinson – “@mamund Disagree that custom media types have, or ought have, PS – that’s the role of a protocol! See AtomPub (which is not a media type)”

@svrc – “@iansrobinson … because I believe custom media types are inherently the wrong long-term direction; they’re the symptom of a gap”

@mikekelly85 – “@iansrobinson media types and link relations are just another part of a uniform interface; they all provide conditions for discoverability”

This is Volume 33 of This week in REST, for Jan 29 2011 – Feb 8 2011. For more information on this blog see this post. If I missed an interesting blog post, discussion or paper – just e-mail me the links, tweet or leave a comment on the latest blog post. Thanks!

Around the Web

Hypermedia is an Event Filter – “In this post, I will re-examine these alternatives, extending the analysis to the information flowing from client to server and the protocols used to exchange information. By doing so, I hope to clarify the advantages provided by REST for input event processing.” (by Andrew Wahbe)

REST and the Web as a Platform – (video) “In this interview, Subbu Allamaraju talks about real life issues of RESTful architectures. He also describes a pragmatic approach of adopting the Web as an integration platform and shares his opinion on OAuth.” (by Subbu Allamaraju)

Minting new Internet Media Type Identifiers – “… a recent discussion on twitter is triggering a quick and dirty run-through of how, when you create a new Internet Media Type (sometimes inaccurately call content type or MIME type), you should create a media type identifier. … A media type identifier is composed of three components: a content type, a content subtype and some parameters that can be specified.” (by Sebastien Lambla)

A proposal for REST and Verbs – “embedding verbs in URIs might not please the purists, but it can make for a highly accessible, practical API.”

CORS considered harmful – “there is no “cross-origin” on the Web. IT’S THE WEB DAMMIT! now, i understand that the common Web browser has problems; lots of them. but “the Web” is not one of them. instead of modeling the Web as the browser, it should be the other way ’round.” (by Mike Amundsen)

Being in a State of REST – Nice intro-level presentation. (by Aslam Khan)

Maze+XML media type approved! – “i got good news last week. my application to the IANA for registration of my Maze+XML media type was approved! yep, it’s official; i am ‘up on the big board'[grin]!” (by Mike Amundsen)

REST — What is State, anyway? – “REST stands for “Representational State Transfer”, which is kind of funny if you think about it, because it is an architectural style based on stateless communications. It says, use stateless communications to transfer state. … So what’s the state that we’re transferring, and at what point do we cross the line into non-stateless communication?”

Breaking the Web with hash-bangs – “Gawker, like Twitter before it, built their new site to be totally dependent on JavaScript, even down to the page URLs. The JavaScript failed to load, so no content appeared, and every URL on the page was broken. In terms of site brittleness, Gawker’s new implementation got turned up to 11.Every URL on Lifehacker is now looks like this http://lifehacker.com/#!5753509/hello-world-this-is-the-new-lifehacker. Before Monday the URL was almost the same, but without the #!. So what?” (by Mike Davies)

Jargon in REST – “The REST uniform interface constraint is a specific guard against jargon. It sets the benchmark high: All services must express their unique capabilities in terms of a uniform contract composed of methods, media types, and resource identifier syntax. Service contracts in REST are transformed into tuples of (resource identifier template, method, media types, and supporting documentation). Service consumers take specific steps to decouple themselves from knowledge of the individual service contracts and instead increase their coupling on the uniform contract instead.” (by Benjamin Carlyle)

AWWSW Status Report – Status report from the Architecture of the World Wide Semantic Web members.

Software frameworks

Hypermedia and the future of the integration over the web – “Restfulie’s first attempt to create a Ruby client for hypermedia services was in late 2009 with 100 lines of spaghetti ruby code. Eighteen months and lots of contributions later, Restfulie Ruby 1.0 is out: tackling both the server and client side on hypermedia based systems.” (by Guilherme Silveira)

REST discussion group and other mailing lists

The relation of Linked Data/Semantic Web to REST – “How are the principles of Linked Data as data publishing guide (independent of Semantic Web technology) and  the Semantic Web as common, standardized technology stack for machine-processable knowledge representation and management in the Web related to the the principles of REST as an architectural style for distributed hypermedia systems?”

Link header is representation metadata? – “can I get a definitive answer (please :)) on whether the Link header is representation metadata (like Content-Type), or not?”

Loose coupling – a RESTful myth? – “is often stated, that RESTful services decouples client and server, as e.g. stated here [1]:”Coupling between client and server is removed, server owners need not know about client particularities to evolve the servers without breaking clients.”But i think, the most server changes will break even the RESTfuls´ clients. At least in business scenarios.”

RESTful? – Interesting analysis of the RESTfulness of an HTTP API.

TAG work on registries (ACTION-511) – “It was an early principle of web architecture to try to avoid using registries and registry processes as a way of defining terms, but to rely on the power of the web itself for “distributed extensibility”. (You could say that before the web, the idea of hypertext was limited because the hypertext systems predating the web had a closed architecture for hypertext extensibility; this allowed referential integrity at the expense of an N-squared communication cost for web-content extensibility). In practice, though, there are situations where the overhead of using a full URI for extensibility (such as is done with XML namespaces) is deemed to be too cumbersome, and protocol designers prefer using registered shorter terms (or prefixes) instead.”

Events

WS-9: The First Workshop on Adoption of REST and LinkedData (ARALD 2011) – Workshop as a part of the SAINT2011 : The 11th IEEE/IPSJ International Symposium on Applications and the Internet in Munich, GERMANY (July 18-22, 2011).

Interesting tweets

@AndrewWahbe – “The problem with conneg is that 2 event models (hypermedia is an event filter) yield 2 state machines (i.e. resources) for same app”

@dret – “@darrel_miller server-side frameworks often affect your freedom as “URI designer”. they shouldn’t, though, or only as an option. #REST

@dret – “URI as UI: URI opacity means that implementation design should not affect URI design; seize the opportunity and design them well.”

This is Volume 32 of This week in REST, for Jan 8 2011 – Jan 28 2011. For more information on this blog see this post. If I missed an interesting blog post, discussion or paper – just e-mail me the links, tweet or leave a comment on the latest blog post. Thanks!

Around the Web

Uniform Interface Wins – “For smaller scale sets of interfaces and users, custom interfaces work fine.  However, such an approach doesn’t scale up to enormous graphs of interfaces and interface users.” (by Ray Polk)

Seven ways to think like the web – “Back in October, at the Traction Software users’ conference, I led a discussion on the theme of observable work in which we brainstormed a list of some principles that people apply when they work well together online. It’s the same list that emerges when I talk about computational thinking, or Fourth R principles, or thinking like the web. Here’s an edited version of the list we put up on the easel that day…” (by Jon Udell)

RESTful SOA or Domain-Driven Design – A Compromise? – (video) “Vaughn Vernon advocates using DDD’s strategic modeling patterns when integrating services in a RESTful SOA implementation, avoiding one of SOA’s pitfalls: focusing on services rather than the domain.” (by Vaughn Vernon)

W3C Technical Architecture Group Status Report (August – December, 2010) – This is a report from the W3C Technical Architecture Group to the W3C membership on TAG activities from August through December, 2010.

on generic, specific, and custom media types – “my point here is to highlight my wide range of approaches at media type design (so far). while it’s true i tout the potential positive values of custom media types, it is not at all true that i favor ‘generic’ over ‘specific’ designs. it’s important keep these two aspects (‘custom’ vs. ‘generic|specific’) of a media type clearly separated. the assumption that goes along with the ‘custom’ attribute is that the media type suffers from a small reach or limited distribution. also, there are folks who are of the opinion that media types whose reach is limited should not be considered ‘valid’ or ‘viable’ media types (for “the Web” or for “the RESTful Web”,etc.).” (by Mike Amundsen)

Is REST important for Cloud? – “With more a more Cloud implementations being developed by vendors and open source efforts, their RESTfulness is usually mentioned as an important feature. But William’s question remains: if the most successful Cloud vendor to date does not use REST, does it really matter?” (by Mark Little)

The seeds of REST’s destruction – “Having a nice, clean ideal like strict REST is wonderful. But at some point you have to listen to what the Universe is telling you. If the Interwebs were not built on REST, and the larger body of software developers are not adhering to REST now, what is the message we should be getting?”

What does a URI name? agree? – “A representation of information, and U refers to that information (format agnostic) and we retrieve that information by using U as name for the purpose of referencing.So U is always used to refer to information about a thing, and that thing can be anything. — I’m interested to know, if anybody disagrees?” (by Nathan Rixham)

Roy Fielding: Geek of the Week – An interview with Roy Fielding from August 2010, touches upon REST, SPDY, OpenID and many other technologies. (Richard Morris)

Using Google Protocol Buffers Hypermedia Type with WCF RESTful Services: A media type processor sample – “Given its optimal representation of structured data, protocol buffers it’s a great option for representing data processed by RESTful services. To follow the principles of REST, protocol buffers should be a represented as a new hypermedia type. In the current version of Windows Communication Foundation (WCF), incorporating a new media type requires a significant amount of effort. Fortunately, the new version of the WCF HTTP stack makes media type a first class citizen of the WCF programming model.” (by Jesus Rodriguez)

The REST bubble – “But when an API document starts with a REST lesson and when PowerPoint-waving sales reps pitch “RESTful APIs” to executives you know this REST thing has gone way beyond anything related to “the fundamentals”. We have a REST bubble on our hands.” (by William Vambenepe)

RE: The REST Bubble – “In the end, longer-term case studies will do a much better job of illuminating whether or not REST actually delivers on the (business) value it promises, and whether the “simpler” solutions for the short-term continue to be sustainable and cost effective in the long run. Until then, you’re probably jumping the gun a bit.” (by Mike Kelly)

regarding the “REST Bubble” : piling on… – “I predict, as w/ SOAP-RPC, this current HTTP-RPC fad will run full course in about ten years due to relativley similar problems (protocol mismatches and failures w/ long-term evolvability). check w/ me around 2018 or so. then we’ll see what new marketing fad will be on the rise in ‘big IT.’ i have no idea what that fad might be. but i am pretty sure of one thing.the next big IT marketing success will not be Fielding’s REST” (by Mike Amundsen)

Should REST be Organic? – “I think we’ve all had negative experiences with trying to follow an architectural principle (REST, OOP, or whatever) religiously.  I think most of us realize that focusing on delivery to market through multiple iterations and user requirements and feedback is much more important than whether we religiously follow a specific guideline.  The easy answer is “Then don’t call it REST!”, but we’d have a very limited vocabulary in software engineering if this mantra was followed with every new architectural style that was created.” (by Bill Burke)

Using REST and the cloud to meet unexpected and unusual demand – “Every so often this business gets unexpected spikes, these spikes aren’t a result of increased volume through the standard transactions but are a result of a peak on specific parts of their site, often new parts of the site related to (for instance) sales or problem resolution. The challenge is that these spikes are anything from 300% to 1000% over their expected peak and the site just can’t handle it.So what is the solution? The answer is to use the power of HTTP and in particular the power of the redirect.” (by Steve Jones)

Repurposing the Hash Sign for the New Web – “The Hash sign (#) in a URI was originally used to introduce a static “fragment identifier”, but recently it is being used in many more complex ways as it is set by and interpreted by JavaScript in Web applications. Fragment identifiers are used to provide several different kinds of parameters to the client-side application, such as the actual URI of a video to be played to a video player, or the position and zoom to a map. Unlike search parameters preceded by “?”, the characters in the URI bar after the hash can be changed without causing the page to be reloaded. Applications and toolkits using fragment identifiers in this way often go to some effort to keep a history and make sure the back button works as expected. Accessibility and search can, however, be compromised because without running JavaScript, the URI has no meaning. Such uses of the “fragment identifier” have interesting and different properties, and differs from the way it is currently described in specs. This document explores the issues that arise from these new uses of fragment identifiers, and attempts to define best practices.” (by T.V. Raman, Ashok Malhotra)

Final Word on REST Resources – “As engineers, we spend so much time in our world providing clarity around our data model, whether it’s a database schema, and object model, or even a file of comma-separated values, that it pains us when we hit a generic term like Resource, that can’t always be defined with that precision.”

experimenting w/ RESTful clients – “i am working on various abstract models for implementing RESTful hypermedia clients. IOW, i think there are some key abstractions that all RESTful client applications share. i am also testing some ideas on M2M (machine-to-machine) clients along the way. if this work pans out, i expect to have some clear ways to talking about designing and implementing client appliations that are hypermedia-aware, follow RESTful principles, and can support some level of M2M operations.” (by Mike Amundsen)

The ‘Internet of things’ needs to be service-oriented – “The paper discusses the differences between REST and DPWS, points at several features of DPWS that are addressed in limited ways by REST (and vice-versa) such as service discovery: you can discover REST resources by getting their URI (HATEOAS but how do you get that URI in the first place, how do you resolve it?) and proposes the use of small local units, called LDUs (Local Discovery Units) to enable the discovery of both DPWS and REST services.” (by Dominique Guinard)

B2B Applications for REST’s Uniform Contract constraint – “This is very much how the REST uniform contract constraint works both in theory and in practice. We end up with a uniform contract composed of three individual elements: The syntax for “resource” or lightweight service endpoint identifiers, the set of methods or types of common interactions between services and their consumers, and the set of media types or schemas that are common types or information sets that are exchanged between services and their consumers. By building up a uniform contract that focuses on the what of the interaction, free from the business context “why” we are free to reuse the interface in multiple different business contexts.” (by Benjamin Carlyle)

Atomic Transactions for the REST of us – (presentation) Does REST need transactions and a protocol for achieving them. (by Cesare Pautasso)

Software frameworks

Jersey 1.5 is released – “We have recently released version 1.5 of Jersey, the open source, production quality, reference implementation of JAX-RS. The JAX-RS 1.1 specification is available at the JCP web site and also available in non-normative HTML here.”

Bowler – “Bowler is a RESTful, multi-channel ready web framework in Scala with a functional flavour, built on top of Scalatra and Scalate, with Lift-JSON doing the heavy JSON lifting.”

EasyHttp – “As of late, much of the code I write, somehow or other has to communicate with an HTTP server. Be it a “ReSTful” service or a “Wanna-be-ReSTful” service, I’ve had the need to make GET, POST, PUT et al operations and work with JSON.After writing smaller wrappers around WebRequest on a few occasions, I decided it’s time to formalize the wrapper. This has given way to EasyHttp.”

Events

WS-REST 2011 – “The deadline for submitting papers for WS-REST 2011 has been extended to 10 February 2011. If you haven’t already submitted a paper, now’s your chance.”

Interesting tweets

@AndrewWahbe – “Step 1: Coin the term “Platform as a Browser” (Done! That was easy!) Step 2: Explain what the hell I mean by that (Will take some time…)”

@stilkov – “What’s the current status of standardization of hypermedia support in JSON, particularly link relations? Any current list of efforts?”

@darrel_miller – “Most of REST’s constraints are focused on preserving independent evolvability over time, which is only measurable on the scale of years” RF

This is Volume 31 of This week in REST, for Dec 13 2010 – Jan 8 2011. The last few weeks have been chaotic and I know I’ve been lazy in maintaining the blog and that it was more a This *month* in REST blog. Anyway, for more information on this blog see this post. If I missed an interesting blog post, discussion or paper – just e-mail me the links, tweet or leave a comment on the latest blog post. Thanks!

Around the Web

agent-driven conneg in HTTP – Excellent post on content negotiation. “in agent-driven conneg, the server sends the client a list of available representations of the requested resource and the client application selects the one to view. this is very different from the more common Server-Driven Negotiation where the client sends the server a list of preferred content-types (via the Accept header) and the server decides which representation to send to the client.” (by Mike Amundsen)

Using REST for SOA – “Stefan Tilkov makes a case for using REST in an enterprise SOA solution showing how to implement tricky features like encapsulation, transactions, stateful communication, reliable messaging, notifications, and security. He also offers advice on how to convince the management to use REST and how to implement it at the enterprise level, including mixing it with WS* when mandatory.” (by Stefan Tilkov)

Is REST === ROA? – “There is this idea, that I am fond of, that RESTful services are the same as Resource-oriented Architecture. That if you expose a service, follow all the REST rules, and diligently follow the GET PUT POST DELETE model, then you have an ROA system. … I’m still kicking the idea around, but in the end I think we’re going to have to get rid of the idea that REST is ROA. They are very compatible, but still not the same.”

Talking Shop Down Under Episode 39 – Jim Webber, REST and Neo4j – (audio) “This week Richard talks with Jim Webber about the recent YOW! conference, REST architectures and the Neo4j Graph Database. ” (by Richard Banks and Jim Webber)

REST — Verbs or Adverbs? – “Maybe the answer is that the HTTP/REST verbs should not be taken as verbs, but rather as adverbs. That is, a method that you invoke GETly has certain properties: it’s probably cacheable, it takes simple input and returns complex data, etc.”

URL Design – “URL Design is a complex subject. I can’t say there are any “right” solutions — it’s much like the rest of design. There’s good URL design, there’s bad URL design, and there’s everything in between — it’s subjective. But that doesn’t mean there aren’t best practices for creating great URLs. I hope to impress upon you some best practices in URL design I’ve learned over the years and explain why I think new HTML5 javascript history APIs are so exciting to work with.” (by Kyle Neath)

URL design – A semi-reply/semi-continuation of the previous blog on URL design touching upon Content negotiation and fragment identifiers.  (by Jeni Tennison)

Restfulie Java: quit pretending, start using the web for real – “Its time to release Restfulie Java, offering the same power encountered in its ruby release, through the use of dynamic bytecode generation and request interception using VRaptor.” (by Guilherme Silveira)

The Role of Hypermedia and the Future of Web Integration – (video) “Guilherme Silveira considers that RESTful web services need to make use of hypermedia in order to be prepared for web integration. He shows how links can be used to create more decoupled services.” (by Guilherme Silveira)

Hypermedia: making it easier to create dynamic contracts – “In a RESTful application the contract depends on its context, which is highly affected by three distinct components: 1. your resource’s state … 2. your resource’s relations … 3. your resource’s operations”  (by Guilherme Silveira)

Interesting tweets

@dret – “design state representations, taking into account interactions with fragments; decide when to pass by value and when by reference #RESTin140

@svrc – “Actually, grand challenge #2 for 2011 is to figure out a decent hierarchical state machine / goal-directed RESTful client framework”

@darrel_miller – “Any REST folks know of a good source of information relating to managing client state in a browser application that is using AJAX?”

This is Volume 30 of This week in REST, for Nov 21 2010 – Dec 12 2010. For more information on this blog see this post. If I missed an interesting blog post, discussion or paper – just e-mail me the links, tweet or leave a comment on the latest blog post. Thanks!

Around the Web

URI Identity and Web Architecture Revisited – “This document reexamined the URI’s identity issue and the debate regarding the nature of “information resource”. By making emphasis on the abstract nature of resource and the role of URI as an interface to the web, this article presented an alternative viewpoint about the architecture of the web that would allow us to objectively and consistently treat all kinds of resources.” (by Xiaoshu Wang)

Web of Things Core Concepts Paper – “In this paper, we begin by describing the Web of Things architecture and best-practices based on the RESTful principles that have already contributed to the popular success, scalability, and modularity of the traditional Web. We then discuss several prototypes designed in accordance with these principles to connect environmental sensor nodes and an energy monitoring system to the WorldWideWeb. We finally show how Web-enabled smart things can be used in lightweight ad-hoc applications called “physical mashups”.” (by Dominique Guinard, Vlad Trifa and Erik Wilde)

Registering A Media Type, Part I – “as part of my ongoing work to learn about how MIME media types are used w/ HTTP and other app-level protocols, i am going through the process of designing and registering a media type with the IANA standards body. along the way, i’m going to blog my experience. hopefully this will be helpful to others when they want to register their own custom media types.” (by Mike Amundsen)

Web Linking – “A couple months ago, Mark Nottingham’s Web Linking internet draft made its way to RFC status. This is a pretty significant specification for the web. It does three key things: It provides a generic definition of a “link”; It establishes a registry for link relations; and It defines the HTTP link header.” (by Andrew Wahbe)

API for RDF? don’t do it! – “There is little doubt that that RDF is powerful and valuable. but i predict RDF will continue to suffer slow adoption rates and limited use (as it has for the last ten years) until work is done to bring the expressive power of the the full set of Hypermedia Factors to an RDF-based media type.” (by Mike Amundsen)

Hypermedia-Driven RESTful Service Composition – “We explore RESTful service composition as it is driven by the hypermedia net that is dynamically created while a client interacts with a server resulting in a light-weight approach. We based our proposal on a hypermedia-centric REST service description, the Resource Linking Language (ReLL) and Petri Nets as a mechanism for describing the machine-client navigation.” (by Rosa Alarcon, Erik Wilde, and Jesus Bellido)

The domain model as REST anti-pattern – “The point that all of these types of articles miss is the HATEOAS part, the hyperlinking of resources. If you expose your domain model, basically saying “here’s all I got, use as you see fit”, there is no sensible way to create links between resources that expose the application state. There is no sensible way to tell the client “here’s what you can do next”, because the “REST” API allows anything at any time.” (by Rickard Öberg)

Back to Basics with Linked Data and HTTP – “I’ve always been of the opinion that this debate could have been avoided by keeping the responsibilities of each component of the Web separate and clean. The seperation should be: identify things using URIs, transfer information using HTTP, encode meaning in the data formats used in the transfer. Instead, we have special interpretations of certain parts of URIs and special interpretations of certain HTTP status codes to infer special meaning on the information being transferred. I think it’s time to stop blurring those responsibilities so I’m going back to basics.” (by Ian Davis)

JSON, XML and the Web – “There are still plenty of use cases for ‘documents’ of XML, but APIs on the web is not one of them.” (by Joe Gregorio)

Generic Media Types Potentially Leak The Model – “… He was worried that an MVC based approach to creating representations exposes the model to the service consumer. Interestingly, this is only possible if the service uses generic media types. Specific media types sufficiently limit the kind of information that can be expressed in the representations and prevent the service specific model to be visible to the outside.” (by Jan Algermissen)

Repurposing the Hash Sign for the New Web – W3C Working Draft, Putative TAG Finding: “The goal of this finding is to initially collect the various usage scenarios that are leading to innovative uses of client-side URI parameters, along with the solutions that have been developed by the Web community and make some architectural recommendations.” (by T.V. Raman and Ashok Malhotra)

REST versus SOAP for the Public Cloud – “For services tageted for the public cloud, REST is a better option than SOAP based Web Services.” (by Herbjörn Wilhelmsen)

Hypermedia APIs (“The rest of REST”) – Slides for a short presentation on REST APIs held at Oredev. (by Jon Moore)

SOAP and REST are not interchangeable – “Comparing the performance of REST to SOAP is like asking: “What tastes better? ‘Stir fried’ or ‘zucchini’?” or “Which one is better? ‘Darth Vader’ or ‘Star Trek’?” Those question just don’t make any sense. People who think that they do are probably the same who think that REST is nothing but “RPC via URI”, which of course it is not.” (by Juergen Brendel)

Events

WS-REST 2011 – WS-REST 2011 is ON! The workshop was accepted by the WWW2011 so start dumping and shaping your RESTish thoughts into papers. You can follow the WSREST2011 twitter stream here.

Books

Web of Things Cook-book! – “Meanwhile please enjoy the draft of our chapter, which is basically something we wanted to come up with for a long time: a cook-book on how to implement the Web of Things in your daily prototypes and/or products. This chapter was written in a way that it is accessible to a broad range of people not necessarily familiar with the core of modern Web-technologies.” (by Dominique Guinard, Vlad Trifa, Friedemann Mattern, Erik Wilde)

REST discussion group

A media type for case files, dossiers and documents – “Can anybody help with some inspiration for a media type for case files, dossiers and documents? This is for a project where we are going to exposethose kinds of govermental data.”

REST (Richardson) Maturity Model – missing “media types” level? – “In the richardson maturity model is explained by fowler. I´ve already seenthis in the recently published book “REST in practice”. I´m missing “mediatypes” between level 2 and 3. I think, before you may think about linkrel´s youshould think about proper media types…”

Representation Format in Hypertext – “I’m designing a REST API which support html and JSON. (might support XML later) It said that REST API should be hypertext-driven, so shall I put the format inURL of collection resource?”

HTML REST API example [was: Link relations] – Another “epic” (long) thread about link relations, m2m, media types and basically everything RESTful.

Interesting tweets

@Grumpydev – “@ryansroberts it’s not ReST unless someone is telling you you’re doing it completely wrong ;-)”

@dret – “hackable URIs are nice for debugging and ad-hoc navigation. when their patterns creep into code, they unnecessarily increase coupling. #REST

@AndrewWahbe – “It is the client that turns linked data into hypermedia. Without an appropriate client, data is just data.”

@dret – “the web isn’t great because it is an application platform. it’s great and unique because it is an information and service platform.”

@dret – “@mamund for loose coupling you need both data models and service models.#RDF is a data model, #REST is a service model.”

@mamund – “@dret#REST is a service model.” REST is arch model. #HTTP is representation-based app protocol that, used properly, offers low coupling.”

@ryah – “http clients are much harder than http servers”

This is Volume 29 of This week in REST, for Nov 2 2010 – Nov 20 2010. For more information on this blog see this post. If I missed an interesting blog post, discussion or paper – just e-mail me the links, tweet or leave a comment on the latest blog post. Thanks!

Around the Web

Will HTTP/2.0 Happen After All? – “…when we started HTTPbis a couple of years ago, there was a strong sentiment against creating a new protocol, both because of the can of worms it would open, and because of deployment problems in doing so. However, I’ve recently heard many people complaining about the limitations of HTTP over TCP, and it seems that one way or another, we’re going to start tackling that problem soon.” (by Mark Nottingham)

Time for REST is over – “The problem is that few web services or RESTful hypermedia describe a data model. Representations themselves don’t often describe a data model, they describe a format. This is the same problem as WS-RT, in that they’re trying to describe updates to a format (XML), not a data model.” (by Stu Charlton)

Is OAuth Stateless? Can it work for REST? – “But one complaint that was kind of annoying was a standard rallying cry of the detractors that OAuth is not stateless. Ergo, it violates the principles of REST, and, ergo, is not consistent with the overall architectural direction. So here is my take on that.”

Exploring resources, a resource programming model, and code-based configuration – Prototype of a new resource programming model in development for WCF. (by Glenn Block)

Beyond Web 2.0 APIs : Implementing RESTful Hypermedia for .NET Applications – Code and slides for a talk on implementing “… RESTful .NET applications using Hypermedia instead of typical Web 2.0 APIs.” (by Mike Amundsen)

XML-RPC keeps chuggin along – “So when people compare SOAP to REST, and not to XML-RPC I wonder if they know that REST is missing something that it should always have had, a standardized way of serializing structs, lists and scalars. That’s something XML-RPC (and SOAP) have always had, and any discussion of these technologies should include that advantage relative to REST, which forces you to cook your own serialization with every API.” (by Dave Winer)

What REST is really about – A post filled with quotes from Roy Fielding’s dissertation explaining what REST is really about. (by Bob DuCharme)

Cookies are gross – “Cookies are crap because they are used to create shared state over a protocol that is deliberately stateless, and session hijacking is just one example of the problems that causes.” (by Mike Kelly)

RESTing at Øredev – “There was quite a bit of REST chatter at Øredev last week.  I sat in on the REST in Practice tutorial by Ian Robinson and Jim Webber (if you have not read the book they co-authored, then do – it’s really well written).  There were a couple of things that these two guys cleared up for me, in the tutorial and in conversation during the week…” (by Aslam Khan)

Partial resource update, one more time – “Alex Scordellis has a good blog post about how to handle partial PUT in REST. It starts by explaining why partial PUT is needed in the first place. And then (including in the comments) it runs into the issues this brings and proposes some solutions. I have bad news. There are many more issues.” (by William Vambenepe)

The Counterintuitive Web – (video) “Ian Robinson considers that programming for the web requires a different architectural approach than for applications: clients are interested only in URIs, clients are responsible for the integrity of a sequence of requests, and one should implement application protocols as protocol resources , not domain resources.” (by Ian Robinson)

Web Linking – “the recently published RFC 5988 (Web Linking) specifies relation types for web links more generally, and definesa registry for them. it also defines the use of such links in HTTP headers using the Link header field. this means that from now on, links for RESTful application do not (necessarily) have to be embedded in representations anymore. instead, if they pertain to the requested resource, they can be communicated in a Link header field, which is specifically mentioned to be semantically equivalent to HTML’s <link> element and Atom’s feed-level<link> element.” (by Erik Wilde)

REST Architecture – Simplified – “Recently, while working on some collaboration functionality for our suite I got a chance to work on a REST (Representational State Transfer) based web server. There are many great resources about REST out there but most of them are quite technical and it took a me a while to get it. So, in this post I am trying to explain in some simple terms what I have understood about REST.” (by Abhishek Rakshit)

Interfaces for Interoperability – “Last week, I presented at QCon in San Francisco on a topic related to the interfaces of the web for interoperability in a track organized by Stefan. The session was about how to use the interfaces of the web to promote interoperability. Here are the slides – Do You Do REST?” (by Subbu Allamaraju)

Why using REST will kill your project – “You see the root of the problem, I believe, is that REST is a heavyweight protocol.  At first when you are designing the APIs in waterfall you try to alleviate this by chunking requests, and having fat methods that return lots of data in one go.  In agile you don’t notice it at first but when you start to scale you notice how slow everything is and how your traditional optimization strategies don’t seem to work so well.  Basing an application on REST is like basing an assembly program on interrupts, as the early Macintosh I/O was, like putting every memory access over a relatively glacially paced network bus.”

The End Of The Road For Web Services – “Web services as a strategy was fundamentally flawed in my view because it was so un-web. It took an idea that hardly worked on an Intranet – remote manipulation of tightly-specified objects – and tried to make it work on the Internet. It led to software applications that by default were complex, brittle and heavy.” (by Simon Phipps)

RESTful architecture: what should we PUT? – Interesting discussion on resource updates and partial PUTs. (by Alex Scordellis)

REST discussion group

Digest Authentication related – “If the client knows in advance that server requires Digest Authentication for aresource, can it include “Authorization” header with each request to avoid 401error? How about nonce and qop in this case. What are the pros and cons of this approach.”

Is it considered bad practice to perform HTTP POST without entity body? –  “I need invoke a process which doesn’t require any input from the user, just atrigger. I plan to use POST /uri without body to trigger the process. I want toknow if this is considered bad from both HTTP and REST perspective?”

Support for PUSH subscriptions – “In my distributed environment I have a host application that provides a list of services. Client applications are able to determine which service is of interest, and then the client wants to receive updates related to that service. I’ve come across two strategies…”

Interesting tweets

@AndrewWahbe – “A standardized way of serializing structs, lists and scalars is missing REST (not the other way around) http://bit.ly/aTyOui

@psd – “@ldodds that’s where I’m at: the Web is turning into a series of Code on Demand leaf-node applications sitting on top of key protected APIs.”

@dret – “minimum overhead & maximum reusability for web-based slide shows: serve plain images with #HTML link relations in #HTTP link headers. #REST

@pkeane – “@dret for syndication, feeds are pure gold. Adding R/W w/ AtomPub less so. We do lots of Atom & JSON out but moving to mostly JSON in.”

@progrium – “Some of the most interesting ideas come from taking existing client-server systems and reversing the role of client and server.”

@savasp – “The #RESTinPractice source code has started appearing at http://restinpractice.com. More is coming soon. Let us know of any issues.”

This is Volume 28 of This week in REST, for Oct 20 2010 – Nov 1 2010. For more information on this blog see this post. If I missed an interesting blog post, discussion or paper – just e-mail me the links, tweet or leave a comment on the latest blog post. Thanks!

Around the Web

W3C TAG meeting 19-21 October 2010 – Agenda and minutes from the recent W3C TAG face-to-face meeting are available. Many interesting topics on WWW architecture were discussed over the three days.

type|use semantics – “a media type defintion may be able to describe the hypermedia interactions needed in order to make that media type useful in a general way, but that same media type may not be able to describe all the possible implementation-specific interactions for a single “application domain.”” (by Mike Amundsen)

WCF Evolving for the Web – Recording of Glenn Block’s talk at E-VAN on 18 October 2010. More about WCF supporting RESTful HTTP here (by Darrel Miller) and here (video recording of Glenn’s talk at MSFT PDC10).

httpbis -12 drafts – New HTTPbis drafts are available.

Code on Demand – “Thanks to efforts like nodejs, server-side Javascript is getting mainstream. Now code-on-demand on the server side is easy. The idea of code-on-demand is simple. The server extends the functionality of the client by sending back code that the client needs to execute.” (by Subbu Allamaraju)

The Web of Things and Sun SPOTs – Slides for a recent presentation on the Web of Things and Sun SPOTs. (by Vipul Gupta)

Web Linking specification reaches RFC status in standards track – “This document specifies relation types for Web links, and defines a registry for them. It also defines the use of such links in HTTP headers with the Link header field.”

Constraints: REST vs. Real Life – “Beware deviating from the path of The Architectural Constraints!” (by Ray Polk)

REST discussion group

Integration “Connector Types” – “…a comparison of the amount of coupling of various connector types”

4 Verbs and CRUD – “It seems like everything now is just CRUD (i.e., Create/Read/Update/Delete)using the 4 HTTP request types. This is good, simple, and gets you a long way.But is everything just CRUD? Isn’t that too limiting? What about situationswhere CRUD isn’t sophisticated enough or just doesn’t fit with what you’retrying to do?”

Fledgling REST blogger looking for suggestions and feedback – Nice introduction of a new RESTafarian blogger with a link to a recent post by Roy Fielding on what the difference between resource state and application state is.

Interesting tweets

@AndrewWahbe – “Links afford clicking, they don’t afford GETing. It is the role of hypermedia to make that translation.”

@dret – “wondering how may “apps” are essentially crippled browsers, i.e. chrome-less rendering for pre-configured URIs and not much else.”

@AndrewWahbe – “Considering a Conditional GET model for Halloween — you only get the candy if you don’t already have some that’s the same”

@sgillies – “@AndrewWahbe Yes. Or a 302 “get your candy next door”.”

This is Volume 27 of This week in REST, for Oct 4 2010 – Oct 19 2010. For more information on this blog see this post. If I missed an interesting blog post, discussion or paper – just e-mail me the links, tweet or leave a comment on the latest blog post. Thanks!

Around the Web

“Put method=DELETE and method=PUT to rest.” [sigh] – “Why is there no PUT and DELETE support for forms in the #html5 editor’s draft” (by Mike Amundsen)

level = (instance|service|media) – “three discreet ways to model client-server interactions for Web-based implementations: 1) Instance Level, 2) Service Level, and 3) Media Level. each of these levels is based on a greater degree of abstraction.” (by Mike Amundsen)

Evolving HAL – “HAL is a hypertext format for m2m interaction.” Very cool description of a hypertext format. (by Mike Kelly)

Should we maybe have a TEST method? – “how a service could be put in the position to redirect a test client to a test-version of the URI space it provides?” (by Jan Algermissen)

Distributed, Integrated or Networked? – “Ok, this post will try to clarify the difference between the three terms you can read in the title, as they are very often confused.” (by William Martinez)

Business process modeling with REST – Presentation on BPM with REST from the SOA/Cloud Symposium in Berlin. (by Cesare Pautasso)

Artifact Ownership or When Not to Use REST – “an indication of situations when applying REST is not appropriate:
When all artifacts that are affected by a possible change are owned by the same project”. (by Jan Algermissen)

Generic vs. Specific Media Types and Evolution – “In addition to the loss of self-descriptiveness there is another problem with generic media types that is not so obvious.” + ” REST’s constraint of specifically typed entities provides for a perimeter within which the server can be flexible without a need to consider the effect the changes have on clients” (by Jan Algermissen)

Hanselminutes: Misunderstanding REST with Mike Amundsen – (audio) “Web Services with SOAP are a pretty well understood thing, but what’s all this appeal about REST? Is REST just CRUD (Create Read Update Delete) for the Web? Is it a pattern, a style or dogma? Recognized REST expert Mike Amundsen sets Scott straight.”

TechTalk – RESTful Application Protocols, From Design to Implementation – (video) TechTalk on RESTful domain application protocols at the Microsoft Development Center in Copenhagen. (by Ian Robinson)

REST API: for infrastructure, domain or application layer? – “in a typical enterprise app there are three options for layers that you might want to expose using a REST API. These are the infrastructure layer, the domain layer, and the application layer.” (by Rickard Öberg)

REST in peace, SOAP – “REST was already the dominant web API style even two years ago, and it keeps gaining ground.”

MVC, PVC and (¬M)VC – “This essay’s thesis is that when separating domain logic from application logic, domain logic can be implemented as a RESTful domain logic server. When doing so, the application can be implemented as an application server with models replaced by proxies to the domain server’s resources such as with ActiveResource in Rails.” (by Reg Braithwaite)

Re: ACTION-434: Some notes on organizing discussion on WebApps architecture – Interesting thread on the W3C TAG mailing list recently reactivated – Web application architecture, state, p2p Web and many more interesting topics.

Events

WSREST-2011 – “#www2011 submission page now open http://is.gd/fSJpB, WS-REST 2011 will submit a workshop proposal and refer to the success of @WSREST2010

Designing HTTP APIs and RESTful Services – Talk at the International PHP Conference 2010. Anyone have a link to a video recording of this talk? Slides are here.

REST discussion group

It’s the architecture, stupid. – Interesting thread with a critique of WebSockets and discussion about a p2p WWW architecture.

More media type questions – “What are some examples of serendipitous reuse that the Web offersapplications today?”

Interesting tweets

@AndrewWahbe – “Upside to script-driven web: coding between the browser APIs and the HTTP interfaces might make devs realize that hypermedia is a mediator”

@darrel_miller – “@AndrewWahbe How long before devs drop the skeleton of HTML tags and just build the page completely from js?”

@AndrewWahbe – “HTML5 is practically a JAR format for Javascript #hypermediaisdead

@mamund – “RT @kidehen: “2 conclude, a #linkeddataresource is at worst a #hypermediaresource with a low H factor re ur def” +1 & that may be enough.”

@mamund – “OH : “media types are uniform interface, link relations are for specific apps”http://go.mamund.com/5ekq #HTTP#REST #LOD #SOA #Hypermedia