<?xml version="1.0" encoding="UTF-8"?>
<posts type="array">
  <post>
    <body>Jeg vil igang med at lave en &quot;Cross Domain Mashup&quot;:http://www.frankvilhelmsen.com applikation der asynkront kan hente data fra forskellige domains. Min klient er i HTML5, CSS3 og naturligvis Javascript. Protokollen er HTTP, kommunikation er asynchronous og indholdet skal v&#230;re JSON fordi det allerede er Javascript, kompakt og ikke beh&#248;ver parsing af nogen art. JSON skal pakkes ind JSONP for at overvinde Same Origin Policy sikkerheds modellen.

Flickr 

Flickr er en fantastisk ressource til at pr&#230;sentere og administrere billeder. De udstiller ogs&#229; en stribe API'er til mange forskellige ting. Jeg har kun interesser for &quot;REST API'et&quot;:http://www.flickr.com/services/api


Den pr&#230;cise URI jeg vil bruge er til min egen foto feed p&#229; flickr. Det er v&#230;rd at bem&#230;rke de sidste parameter i URI'en &quot;format=json&amp;jsoncallback=?&quot;. Disse paramter fort&#230;ller resourcen at response skal v&#230;re i formattet JSON og at kaldet m&#229;ske er Cross Browser og derfor skal JSON pakkes ind som et JSONP kald. Ydermere kan man specificere et callback navn &quot;joncallback=?&quot; ved sp&#248;rgsm&#229;lstegnet hvis man vil have en bestemt metode kaldt n&#229;r script er loadet.

| URI | JSONP |
| &amp;format=json | jsonFlickrFeed({ &quot;title&quot;:&quot;Uploads&quot; }) |
| &amp;format=json&amp;jsoncallback=? |  ({ &quot;title&quot;: &quot;Uploads&quot;}) |
| &amp;format=json&amp;jsoncallback=visfoto | visfotos({ &quot;title&quot;: &quot;Uploads&quot;}) |

Det kan betale sig at unders&#248;ge data grundigt inden man g&#229;r igang med at skrive klienten. Hvis man kan operere/navigere med curl -i URI gennem de &#248;nskede scenarie er man langt. 


Nu klienten. 

&lt;pre&gt;
  $(document).ready(function(){
    $.getJSON(&quot;http://api.flickr.com/services/feeds/photos_public.gne?id=7185299@N07&amp;format=json&amp;jsoncallback=?&quot;,
        function(data){
          $.each(data.items, function(i,item){
            $(&quot;&lt;img/&gt;&quot;).attr(&quot;src&quot;, item.media.m).appendTo(&quot;#images&quot;);
            if ( i == 8 ) return false;
          });
        });
  });
&lt;/pre&gt;

Flickr ressourcen bliver ramt gennem Jquery og henter data. Der itereres gennem data der indeholder title, link til foto location, hvorn&#229;r det er taget og en masse andet. Elementet item.media er en server location men der f&#248;lger et m med som fort&#230;ller noget om de st&#248;rrelse og repr&#230;sentationer som billedet allerede er skaleret til. Pr&#248;v fx at skifte m ud med et s. 

Nu til den n&#230;sten klient app som er twitter updates. Koden herunder henter et antal twitter status update og iterere gennem hver update. Undervejs ledes efter regul&#230;re udtryk der minder om et link tag og hvis udskiftes med et rigtig html link anker. Hver update bliver adderet til hash# div tag. Det er muligt at bruge this[array] til at hente data ud af strukturen. 

L&#230;g ogs&#229; m&#230;rke til at twitter vil have en count parameter med ind for at minimere antal updates over linjen. Bem&#230;rk ogs&#229; at er mere REST aware i det de udnytter HTTP header information om den returnerede repr&#230;sentation og caching TTL i netv&#230;rket. De udnytter infrastrukturen bedre end flickr.  

&lt;pre&gt;
  var regexp = /((ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&amp;%@!\-\/]))?)/gi; 
  $(document).ready(function(){
    $.getJSON(&quot;http://twitter.com/statuses/user_timeline/frankvilhelmsen.json?count=6&amp;callback=?&quot;,
      function(data, textStatus) {
        $.each(data, function(i) {
          var twitter_time = prettyDate(this['created_at'])
          var twitter_uri_encoded_text = this['text'].replace(regexp,'&lt;a href=&quot;$1&quot;&gt;$1&lt;/a&gt;') 
          $(&quot;#statuses&quot;).append(&quot;&lt;li&gt;&quot;+twitter_time+&quot;: &quot;+twitter_uri_encoded_text+&quot;&lt;/li&gt;&quot;);
        });
    });
  });
&lt;/pre&gt;



Server

Indtil nu har jeg kun forbrugt ressource hvor jeg kun kender interfacet men jeg vil jo ogs&#229; gerne udstille mine egne REST baseret Cloud ressourcer. Heldigvis underst&#248;tte rubyonrails dette lige ud af boxen. Min platform er &quot;Heroku | Ruby Cloud, Platform as a Service&quot;:http://heroku.com git og Rails. DNS og alt er sat op. 

&lt;pre&gt;
  p = Post.find(:all, :select =&gt; 'id, title, osv') 
  response_to 
    ...
    format.json {render :json =&gt; @posts, :callback =&gt; [:callback] }
  end 
&lt;/pre&gt;

Det eneste jeg skal g&#248;re for at enable en ressource til cross browser er tilf&#248;je denne &quot;:callback =&gt; [:callback]&quot;. 

Rails har alts&#229; dekoreret JSON til JSONP format uden at jeg beh&#248;ver at g&#248;re mere. Men m&#229;ske ville jeg reagere anderledes p&#229; &#248;nsket om at give parameter som denne med i requestet &quot;&amp;callback=chanceheader&quot;. Direkte til klienten. Og nu er det nemt for koden er n&#230;sen det samme som f&#248;r. 

&lt;pre&gt;
  $(document).ready(function(){
    $.getJSON(&quot;http://XXX/posts/title/all?format=json&amp;callback=?&quot;,
      function(data){
        $.each(data, function(i) {
        $(&quot;#titles&quot;).append(&quot;&lt;li&gt;&quot;+this.post.id+&quot; - &quot; +this.post.title+&quot;&lt;/li&gt;&quot;)
     });
  });
});
&lt;/pre&gt;

 
</body>
    <category-id type="integer" nil="true"></category-id>
    <created-at type="datetime">2010-01-22T11:49:10Z</created-at>
    <id type="integer">157</id>
    <post-id type="NilClass">157</post-id>
    <published type="boolean">true</published>
    <tag-id type="NilClass">25</tag-id>
    <title>Cross Domain JSONP on Rails</title>
    <updated-at type="datetime">2010-01-22T14:32:11Z</updated-at>
  </post>
  <post>
    <body>Titlen p&#229; denne post kan m&#229;ske forekomme misvisende eller ligefrem tvetydig idet den blander to paradigmer, to protokoller og to praktiske modeller. Men netop denne dualisme og tv&#230;rg&#229;ende egenskaber kan resultere i en styrke. Abstrakt handler dette blot om at se p&#229; services som resource. Denne post har absolut intet at g&#248;re med REST men kun om brug og kombination af enkle og gode egenskaber omkring HTTP Applikations Protokollen. 

For at komme i gang vil jeg lige sige et par ord om Mocks. Mocks er objekter der indenholder en forventet reaktion. Man kunne fx mock'e information om &quot;processen af k&#248;be en kop kaffe&quot;:http://www.frankvilhelmsen.com/posts/33-Caf-shop i nogle trin uden af kende hele den samlede proces til bunds. P&#229; den m&#229;de ville kaffe t&#248;rstige sj&#230;le kunne benytte cafe-service'en ved at bestille forskellige type af kaffe. Endda f&#248;r kaffebaren er helt f&#230;rdig. En Stub derimod ville i samme senarie blot returnere den samme kedelige kop kaffe hvergang uden nogen hensyntagen til modtageren. 

Hvad har kaffe med SOAP at g&#248;re? Jo, jeg har modtaget en r&#230;kke l&#248;stformulererede krav til en SOAP service der kan erstatte en ESB. Kravende indeholder ord som enkelhed, robusthed og fleksibel. Sjovt nok h&#230;nger de egenskaber ikke naturligt sammen med de flestes opfattelse af SOAP og WS-. Jeg m&#229; blankt indr&#248;mme at jeg normalt l&#248;ber min vej n&#229;r talen kommer ind p&#229; SOA, SOAP og WS-  &quot;d&#248;dsstjerne teknoliger&quot;:http://www.frankvilhelmsen.com/posts/56-WS-Death-Star 

Men p&#229; samme m&#229;de som en skatterevisor til fest er min interesse altid p&#229; ca. 50 procent n&#229;r noget er dukket op p&#229; omr&#229;det. Min holdning er blot at jeg kan tilf&#248;re mere v&#230;rdi med andre metoder. 

Som udgangspunkt enig med med folkene bag &quot;http://soa-manifesto.org&quot;:http://soa-manifesto.org om at SOA som arkitektur er en god ting og SOAP som protokol er noget markv&#230;rk. Derfor vil jeg bryde alle (mine) principper og fors&#248;ge at angribe med ord som &quot;Brute Force&quot; og &quot;WS-* Duck-Typing&quot;:http://www.frankvilhelmsen.com/posts/21-WS-Duck-typing N&#229;r man operaer med &quot;Brute Force!&quot; metoden er det n&#230;sten det samme bare med mere traditionelle v&#230;rkt&#248;jer. 

Paul Sandoz fra SUN, som i &#248;vrigt sidder i ekspertgrupperne JSR-154, JSR-224, JSR-311 har p&#229; en konference fortalt mig at man kan se p&#229; enhver SOAP besked som en resource. Og hvis ikke er der et design issue. Derfor vil jeg i dette fors&#248;ge at udstille et SOAP endpoint som en resource. Eller rettere, forbrugeren vil ikke opdage en forskel men blot kalde en service som s&#230;dvandeligt men for service udbyderen er der en v&#230;senlig forskel. Klienten kalder med JSR-244 (JAX-WS) og serveren svare med JSR-311(JAX-RS). 

Med denne metode kan jeg overholde WS-* Ducktyping principperne og p&#229; samme tid arbejde highlevel mod HTTP protokollen uden de afledte effekter som codeeksplosion, classeksplosion interoperability og de andre aspekter der bunder i en t&#230;t bundet SOAP protokol. SOAP definere sin egne protokol ovenp&#229; HTTP protokollen og den abstraktion er vigtig set ud fra det perspektiv at man kan skifte transportlag til JMS eller noget andet. Men hvis man kun bruger HTTP som transport er det naturligvis kun en abstraktion der altid vil ende med &quot;Law of leaking abstractions by Joel Spolsky&quot;:http://www.joelonsoftware.com/articles/LeakyAbstractions.html


I denne context er Highlevel er lig med det &quot;Uniforme Interface&quot;:http://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm fra REST der tilbyder ensartede operationer p&#229; tv&#230;rs af alle komponenter. Det er en k&#230;mpe fordel frem for SOAP protokollen hvor hver WSDL definere et specifikt service interface. Med SOAP arbejder man med et lag ovenp&#229; http protokollen mens man med REST arbejder med protokollerne og derfor siges det at abstraktionen mellem de to fremgangsm&#229;der er p&#229; forskellige plan. 

Resoucen 

&lt;pre&gt;
@Path(&quot;/Customer&quot;)
  public class CustomerResource {

  @POST 
  @Consumes(&quot;appliction/soap-xml;charset=UTF-8&quot;)
  @Produces(&quot;appliction/soap-xml;charset=UTF-8&quot;)
  public String method(String body) {
    ...
  }
}
&lt;/pre&gt;

Denne resource klasse repr&#230;sentere en kunde. Path symbolet viser den relative URI til ressourcen. For at kunne attakere denne metode som en resource kan man fx sende et HTTP (@POST) med den rette content-type (@Consumes) i HTTP headeren. Metoden modtager en SOAP besked og returnere en SOAP (@Produces) besked. Hvordan beskeden teknisk behandles i metoden er ligegyldigt. For en brugern af denne SOAP service er det transparent at der benyttes ressource. Ved en fejl i metoden returenes naturligvis en &quot;optional SOAP Fault element&quot;. 

Det er muligt at skabe en @Singelton instans ved at tilf&#248;re en annotation. S&#229;ledes finder der kun den samme ressource for alle consumere og det er muligt at udnytte den feature p&#229; flere m&#229;der end jeg kan komme p&#229; her. Ved Mocking er det selvvalgt en naturlig ting idet man kan &#230;ndre indhold p&#229; ressource output i k&#248;retid. Under normale forhold vil vi naturligvis str&#230;be efter stateless resourcer for at bibeholde egenskaber som skalerbarhed, samtidighed osv. 

Indtil nu er der kun brugt annoteringer fra API'et p&#229; en POJO Java klasse men det er tid at v&#230;lge hvilken implementation der skal bruges. Jeg bruger JAX-RS API og SUN's Jersey 1.1 reference implementation fordi den er langt den mindste jeg kender og har en opstartstid jeg kan udholde. Ikke et ond ord om Apache CXF der har suppport for JAX-RS i sin JAX-WS implementation. Registrering og brug af denne resource kan ske p&#229; flere m&#229;der, b&#229;de standalone og i container. Jersey har en super cool scanner der selv register klasser efter annotationer og binder dem til det rigtige endpoint der dekoreres dels i Web.xml og dels direkte i annotationer. Det bliver ikke bedre end det. :-) 

En af de st&#230;rke sider ved Jersey er deres client interface. Kan ikke lade v&#230;re at vise en stumt kode der simulere et SOAP WS kald mod en ESB eller whatever du nu har. L&#230;g is&#230;r m&#230;rke til den dejligt &quot;Java Fluent Interface&quot;:http://www.frankvilhelmsen.com/posts/111-Fluent-interface m&#229;de man opbygger sin request p&#229;, n&#230;sten i DSL stil. Mange forskellige teknologier har adopteret og overholder HTTP, Servlets og JAX-WS. Det betyder at man kan bruge en ressource som et endpoint for alle komponenter der taler samme sprog. De vil aldrig vide hvad der ramte dem. P&#229; samme m&#229;de kan man bruge klientdelen til at invokere fx ESP endpoints. Det er faktisk sjovt. 

&lt;pre&gt;
  Client client = Client.create();
  WebResource endpoint = client.resource(uri);

  ClientResponse response = endpoint.
      type(&quot;application/soap+xml;charset=utf-8&quot;). 
      accept(&quot;application/soap+xml;charset=utf-8&quot;).
      post(ClientResponse.class, xml);

   int status = response.getStatus();
   String s = response.getEntity(String.class);
&lt;/pre&gt; 

Jersey og hele REST tankegange er baseret t&#230;t omkring HTTP Applikations Protokollen. Man er &quot;ON The Web&quot; eller en del af &quot;The Semantic Web&quot;:http://en.wikipedia.org/wiki/Semantic_Web og ens applikation kan underst&#248;tte &quot;Linkede Data&quot;:http://en.wikipedia.org/wiki/Linked_Data Med disse tanker og metoder smelter applikationen sammen med internettet. 

Den forrige resource &quot;/resource/Customer&quot; vil blive ramt af SOAP klienter. Men jeg kan ikke dy mig for at lade den samme resource blive brugt af simpelt AJAX (Asynchronous JavaScript and XML). Med AJAX kan man fra Javascript kommunikere med en server gennem XMLHttpRequest objektet uden at reload HTML siden. En anden ting er, at man kan kontroller stort set alle de ekstra header informationer som overf&#248;res til serveren hvilkent betyder at man kan rammer en resource fx med en bestemt content-type. 

&lt;pre&gt;
new Ajax.Request(&quot;/resource/Customer&quot;, {
  method:'GET',
  asynchronous:true,
  requestHeaders: ['Content-Type', 'text/html;charset=UTF-8'],
  onSuccess: function(transport){
    $('message').update(transport.responseText);
  },
  onFailure: function(transport){
    $('message').update(transport.responseText);
  }
});
&lt;/pre&gt; 

Denne metode laver en GET p&#229; ressourcen Custormer og forventer at modtage en repr&#230;sentation af dennes response i form af HTML. Hvis man skal bruge JSON skal man kun &#230;ndre content-type til &quot;applikation/JSON&quot;. Hvis man i stedet vil POST'e et &#230;ndret indhold ind i ressourcen kan man bruge denne form:

&lt;pre&gt;
new Ajax.Request(&quot;/resource/Customer&quot;, {
  method:'POST',
  asynchronous:true,
  requestHeaders: ['Content-Type', 'appliction/xml;charset=UTF-8'],
  postBody: $F('body'),
  onSuccess: function(transport){
   ...
&lt;/pre&gt;

Dette POST bindes sammen med ressourcen gennem POST med content-type 'appliction/xml;charset=UTF-8' og forventer at modtage en Customer i XML format som input i HTTP body. Hvis ressourcen ikke har implementeret denne indgang svares med &quot;Status Code 415 Unsupported Media Type&quot;:http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html

Fik jeg s&#229; hvad jeg kom efter? Ja, det synes jeg. Ved at mappe ressource til simulering af SOAP endpoints og Servlets side om side fik jeg en cross platform, cross service implementation og mere clean snitflade uden de logiske layer som jeg hader. H&#229;ber bare at mine kravsstiller ikke vil skifte transport metode. Anyways, det sker nok alligevel aldrig. 

At efterleve DuckTyping principperne er en forn&#248;jelse og jeg har virkelig hygget mig undervejs. Tak til Paul Sandoz for at starte den ide i mit hoved i 2007. 
</body>
    <category-id type="integer" nil="true"></category-id>
    <created-at type="datetime">2009-11-06T17:28:12Z</created-at>
    <id type="integer">151</id>
    <post-id type="NilClass">151</post-id>
    <published type="boolean">true</published>
    <tag-id type="NilClass">25</tag-id>
    <title>Mocking SOAP onto Resources</title>
    <updated-at type="datetime">2009-11-06T17:32:11Z</updated-at>
  </post>
  <post>
    <body>Elektronisk Tinglysning, elektronisk Pension og elektroniske patient journaler er alle gode eksempler p&#229; forretningsomr&#229;der hvor ressource orienteret arkitektur ville v&#230;re en naturlig del af l&#248;sningen. 

Typisk for disse forretningsomr&#229;der er at de logisk tilh&#248;rer et sted eller en instans hvorfra det er muligt at udstille de ofte meget vigtige informationer. Man ser meget n&#248;digt et tinglysningsdokument eller en patient journal hos flere akt&#248;rer p&#229; samme tid. Det er dog muligt at vise en repr&#230;sentation flere steder samtidigt men nye entiteter eller opdatering styres gennem adgang til ressourcen. Hvis man vil tilf&#248;re en kreditor til et tinglysningsdokument f&#229;r man alts&#229; adgang til den ressource hvori en kreditor tilf&#248;res. Derefter kan man f&#229; en repr&#230;sentation af det nye dokument.  

Ressource Orienteret Arkitektur er tankem&#230;ssigt den dimentrale modpol til Service Orienteret Arkitektur. SOA forholder sig til en distribueret verden og udstiller services, hvori gennem fx et tinglysningsdokument deles mellem mange akt&#248;rer. ROA forholder sig til ressource og deler kun adgangen til disse ressourcer som logisk kun eksisterer et sted.

Historie 

Resource-Oriented Architecture blev n&#230;vnt f&#248;rste gang af IBM 2004 {@todo} og siden i en blog entry af Alex Bunardzic med titlen Replacing Service Oriented Architecture with Resource Oriented Architecture som skabte en livlig debat blandt early adopters. I for&#229;ret 2007 udkom bogen 'RESTful Web Services' af Leonard Richardson &amp; Sam Ruby. 

Hvad er Resource Oriented Architecture? 

Resource-Oriented Architecture er en metode til at konkretisere et problem til en RESTful webservice. Et arrangement af URI, HTTP og XML der vil arbejde p&#229; samme m&#229;de som resten af World Wide Web og som b&#229;de mennesker og maskiner kan udnytte p&#229; en let og overskuelig m&#229;de. 

Resource-Oriented Architecture er ogs&#229; RESTful. Men REST i sig selv er ikke en arkitektur men blot et s&#230;t af designkriterier. En arkitektur kan im&#248;dekommer disse designkriterier bedre end andre men der findes ikke en REST arkitektur.  

REST er meget generel og ikke forbundet til WWW. REST er ikke afh&#230;ngig af strukturen i URI'en eller elementer af HTTP protokollen. Men n&#229;r man taler om web services i forbindelse med ROA binder man automatisk Resource-Oriented Architecture til de teknologier som udg&#248;r World Wide Web. 

Frasen _resource oriented_ er blevet brugt til at beskrive generelle RESTful arkitekturer men der er langt til den fulde forst&#229;else.     

Hvad er en ressource?

En ressource er noget som er vigtig nok til at v&#230;re tilg&#230;ngeligt. Alle ressource m&#229; som minimum have et navn og en adresse i form af en Uniform Resource Identifier(URI). Hvis ressource ikke har en URI er det _ikke_ en ressource. URI m&#229; v&#230;re entydige og intuitiv. URI b&#248;r have struktur og variation p&#229; en forudselig m&#229;de. En ressource kan godt have to URI men der kan aldrig findes to ens ressource. 

N&#229;r der findes en ressource med en URI kan man definere to vigtige elementer af ROA: Addressability og Statelessness.

Addressability 
  
_Scoping information: the principle of addressability_

En applikation er l&#230;sbar n&#229;r den eksponere interessante aspekter af data som ressourcer. Siden ressourcer bliver eksponeret gennem URI, levere en l&#230;sbar applikation en URI for hvert stykke v&#230;rdifuldt information den indeholder. For slutbrugerens perspektiv er dette det vigtigste aspekt ved enhver applikation.  

Statelessness

Statelessness eller tilstandsl&#248;s betyder at ethvert kald sker i totalt isolation. N&#229;r en klient udf&#248;rer et kald er alle informationer med i selve kaldet. Serven beror sig aldrig p&#229; information fra det tidligere kald. Hvis et kald kr&#230;ver allerede indhentede information m&#229; klienten sende det igen. 

T&#230;nkt p&#229; tilstand i forbindelse med l&#230;sbarhed. L&#230;sbarhed siger at alle stykker interessant information som serveren kan levere er ressourcer med sin egen URI. Tilstandsl&#248;s siger at alle plausible tilstande fra serveren er ogs&#229; tilstande, og som s&#229;dan ogs&#229; givet sine egen URI'er. En klient b&#248;r aldrig tvinge en server gennem bestemte trin for at komme i en specifik tilstand. 

Der er to typer af tilstande i ROA. Applikations tilstand og ressource tilstand. Serveren kender kun til ressource tilstand. Denne tilstand er ens for alle klienter og lever kun i et enkelt kald mellem klient og server. Derefter er serveren tilstandsl&#248;s og kender ingenting til klienten. Applikationen derimod har en indre tilstand, gerne i t&#230;t forbindelse med brugeren. Den nuv&#230;rende tilstand kommer fra det sidst foretagne kald og dennes repr&#230;sentation fra serveren. En klient kan v&#230;re p&#229; side tre mens en anden kun er p&#229; side et. 

Representations

N&#229;r man dele sin applikation op i ressource for&#248;ges gr&#230;nsefladen voldsomt. Brugene kan konstruere URI'er som passer til deres applikationer, men ressource er _ikke_ data men blot repr&#230;sentationer af data. Serveren returnerer data i et bestemt format og m&#229;ske i et bestemt sprog. Dette er en repr&#230;sentation af ressourcen. En ressource er kilde til mange repr&#230;sentationer.   

Et eksempel p&#229; en URI: http://host.dk/blog/123.da 

Repr&#230;sentationer er virkelige effektive n&#229;r b&#229;de maskiner og mennesker kan bruge samme gr&#230;nseflade. Ind i mellem kan repr&#230;sentationerne indeholde mere end blot seriliseret data, ofte er repr&#230;sentationer hybermedia: dokumenter som indeholder data og links til andre ressource.  

Connectedness 

I &quot;Rod Fielding&quot;:http://roy.gbiv.com disputats om &quot;Representational State Transfer (REST)&quot;:http://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm st&#229;r 'Hybermedia as the engine of application state'. Det betyder kort sagt at klient tilstanden ikke bliver gemt p&#229; serven men kun er applikations tilstand hos klienten og bliver overf&#248;rt gennem URI'erne. Serveren giver klienten ved at overf&#248;re hybermedia links og forms indeni hybertext repr&#230;sentationer. 

Kvaliteten af fremsendte hybermedia er bla baseret p&#229; de n&#230;ste klikbare tilstande. Se fx google, de sender altid next link, page 2, related to this osv    

Det menneskelige Internet er let at benytte fordi det er godt forbundet.  

Uniform Interface

_Method information: the principle of uniform interface_

P&#229; World Wide Web er der kun nogle f&#229; basale ting man kan g&#248;re med en ressource. HTTP levere fire grundl&#230;ggende metoder for de mest almindelige operationer. 

@todo Why the Uniform Interface matters</body>
    <category-id type="integer">11</category-id>
    <created-at type="datetime">2007-11-02T11:00:00Z</created-at>
    <id type="integer">80</id>
    <post-id type="NilClass">80</post-id>
    <published type="boolean">false</published>
    <tag-id type="NilClass">25</tag-id>
    <title>Resource Oriented Architecture (ROA)</title>
    <updated-at type="datetime">2008-02-18T09:46:14Z</updated-at>
  </post>
  <post>
    <body>If you are an architect or developer working on service-oriented architecture projects you probably are not doing representational state transfer now.

But within the next five years you will.

Looking to the future, Burton predicts that REST adoption is now and in the next three, five and 10 years.

Today, it is only innovators that are really working with REST. But within the next three years we should see the early adopters start to play with REST. It will probably be five years before it is adopted by the early majority.
What will drive REST adoption eventually is that it brings structure in the form of constraints to the sometimes chaotic world of Web services It will provide a level of maturity for SOA development.

So what does this mean to IT departments in general, and enterprise architects and developers in particular? It depends on the skills of the architects and developers and their willingness to think outside the box of object-oriented programming.

The basic concept of REST which starts with sending out GET commands sent via HTTP to URIs to retrieve data is simple enough. But noted that even long-time REST advocates admit having trouble thinking of applications in terms of REST.

Frameworks and tools for designing and building such REST applications are coming from major vendors, especially IBM and Microsoft which are making major investments in the technology, she said. It is also coming from the open source community. The new version 2.0 of Ruby on Rails will make it easier to do REST Web services. A major vendor commitment was confirmed this past week by Jerry Cuomo, IBM Fellow and WebSphere CTO, who said in an interview at IBM's Impact 2007 conference in Orlando, that Big Blue also sees REST as the next big thing.

But architects and developers will not have long to wait before REST is baked into frameworks. You're going to see some very interesting frameworks come down the line in the not too distant future.</body>
    <category-id type="integer">3</category-id>
    <created-at type="datetime">2007-06-03T22:50:00Z</created-at>
    <id type="integer">44</id>
    <post-id type="NilClass">44</post-id>
    <published type="boolean">false</published>
    <tag-id type="NilClass">25</tag-id>
    <title>Future of SOA is REST</title>
    <updated-at type="datetime">2008-04-08T07:25:16Z</updated-at>
  </post>
</posts>
