Abstract

AJAXLink is based on principles of Web linking and new possibilities to extend browsers with JavaScript code which talks to a server. While AJAXLink is designed to run in any browser, an alternative implementation as a browser-specific extension could use interface techniques which are not available to AJAX applications. In this lecture, we look at the foundations of AJAXLink and at the core components of the project, which are the client side, the communications protocol, and the server side.

Fragment to Resource

• Most Web links start at fragments and link to resources
  • the link originates from text or an image
  • it points to a a resource on the Web, in most cases a new HTML page
  • the browser load the new resource and the users starts reading
• Linking to complete resources has its advantages
  • links can be created with great ease by cut&past-ing the URI from the address field
  • as long as the resource exists, the link will work (even if the resource is modified)
• But there are also disadvantages to this approach
  • when linking to bigger documents, locating the relevant part can be hard
  • even if the resource changes completely, the link will still point to it
  • it is hard to represent incoming links, even if this information were available

Fragment to Fragment

• HTML allows linking to fragments (…#id URIs)
  • fragments must be identified by an id attribute (on any element)
  • rarely used but very useful (in particular for bigger documents)

<tr id="written2007" class="line1"> … </tr>

*:target { outline : red solid medium ; }

Resource to Resource

• HTML supports document relationships (part of the document head)
  • a very useful feature for better navigable sites (standardized site navigation)
  • poorly supported by today's browsers (only Opera provides native support)
  • Firefox's cmSiteNavigation extension provides support in Firefox
  • additional link types for advanced features (HTML supports meta data profiles)

AJAX = DHTML + HTTP

• DHTML (HTML & JavaScript) uses JavaScript locally
  • the scripting code reacts to user events and accesses the DOM structure
  • changes are either hardcoded or derived from user events
• AJAX adds an HTTP request method to JavaScript
  • scripting code can now request additional data from an HTTP server
  • changes can thus be made based on any data received from the server
• AJAX dramatically reduces the number of page reloads
  • any change of the page can be done without a complete reload
  • based on user interactions, parts of the page can be reloaded
• AJAX has the same interoperability problems as DHTML

AJAX and DHTML

AJAX and XML

• The XMLHttpRequest API has been built for requesting XML via HTTP
  • this is useful because XML is the most popular data format
  • all requested data has to be processed by using XML access methods in JavaScript
• JavaScript Object Notation (JSON) encodes data as JavaScript Objects
  • because the consumer is written in JavaScript, this is more efficient for the consumer
  • this turn the generally usable XML service into a JavaScript-oriented service
  • for large-scale application, it might make sense to provide XML and JSON
  • using HTTP Content Negotiation, this could even be negotiated on the HTTP protocol level

AJAX vs. Extensions

• AJAX code is loaded and executed with the Web page
  • any (modern) browser supports AJAX applications
  • users do not have to install any code, it is automatically loaded
  • AJAX bookmarklets can be used to separate AJAX code and resources
  • there is only limited access to resources (on the server as well as the client side)
• Extensions are installed as part of the browser
  • for large-scale deployment, extensions are a serious obstacle
  • extensions are browser-specific (versioning problem with browsers and platforms)
  • extensions allow a much better integration with the browser interface
  • there are far less security restrictions for extensions

AJAX Code

• AJAX code can be embedded in all pages using a linkbase
  • requires page authors to explicitly add the code to their pages
  • only works if the pages and the linkbase use the same domain name
• Useful as a proof-of-concept implementation
  • allows declarative Web design with feature unknown in plain HTML
  • many useful applications as a platform for advanced Web publishing
• Restricted in terms of supported scenarios
  • external links can be used for advanced Web design
  • third-party links are not really possible
  • advanced XLink scenarios are better supported with an extension

Browser Extension

• A lot of code to share with the AJAX version
  • the basics of retrieving links and embedding them are identical
  • extensions need to be shipped in a different container (for installation)
  • additional code for managing access to third-party linkbases (filters)
• Browser-specific and installation required
  • possible deployment more limited than for pure AJAX
  • improved interface design possibilities (sidebars, toolbars, menu items)

XML Database

• XLinks are XML (and they can even contain embedded resources)
  • XML databases can easily handle XML data
  • no mapping from/to relational structures required
  • XML database naturally support querying into any XLink
• Database programming requires XQuery
  • W3C recommendation since 23 January 2007
  • small choice of implementations and programming frameworks
  • XQuery is read-only, update part still under development
• XML database could provide support for pluggable XQueries
  • instead of getting XLink XML, users can get anything they want

Relational Database

• XLink's structure is easy to understand and map
  • a mapping to a relational structure can be easily defined
  • the only problem are embedded resources, which can be arbitrary XML
• Many users feel more comfortable with a relational database
  • there is a large number of administrative experience and tools
  • a large number of Web programming frameworks support relational databases
  • several robust and free relational database systems can be used

REST

• REST is a design, implementations can use any language
  • XQuery can serve as a middle tier for REST services
  • Ruby on Rails 1.2 introduces HTTP and REST oriented features
• REST focuses on simplicity and revolves around resources
• Good REST is as hard to grasp as good OO
  • products may claim that they are REST/OO
  • they may even use technologies which support REST/OO
  • only careful inspection reveals the truth of this claim
  • in most cases, this only happens when the product needs to be changed

REST Protocol Design

• How to Create a REST Protocol? … some possibilities:
  • retrieving links from a linkbase (receiving 0-n XLinks as a result)

    GET http://example.com/linkbase/lb42?href=http://example.com/doc.html

  • adding links to a linkbase (sending XLink XML as request entity)

    POST http://example.com/linkbase/lb42

    HTTP/1.1 201 Created
    Location: http://example.com/linkbase/lb42/link4242

  • updating links in a linkbase (sending XLink XML as request entity)

    POST http://example.com/linkbase/lb42/link4242

  • removing a link from a linkbase

    DELETE http://example.com/linkbase/lb42/link4242

  • creating a linkbase (the name of the new linkbase known)

    PUT http://example.com/linkbase/lb43

Declarative Web 2.0

• Some Web 2.0 features can be expressed as XLinks
  • dynamic Web pages often can be expressed in XLink
  • this has its limitations (e.g., Google Maps cannot be expressed in XLink)
• AJAXLink hides JavaScript programming from Web designers
  • for simple tasks, it may be sufficient to include XLinks and AJAXLink
  • for more complex tasks, AJAXLink might need to be extended
  • well-designed AJAXLink code would have easily usable extension points

Options, Options, Options

• We need at least three basic building blocks
  • one Server implementation
  • one Client implementation
  • the Protocol to connect these two
• We also need interface design
  • XLinks need to be rendered for user interactions
  • linkbase access and filtering needs a well-designed interface
• We need applications for AJAXLink
  • basic applications for something like SSI on steroids
  • advanced applications to understand how extensions should work