Evaluation

I started by reading the “Life Above the Service Tier” document, which was a description how it works today (and its flaws) and what the proposed solution is.
Also, I browsed the web for more articles, blog posts and comments on the issue.

Summary

The ideology (called SOFEA: Service-Oriented Front-End Architecture) is basically to put more rendering logic on the client side and only use the server side to transport data back and forth.

The principles of SOFEA could be implemented with help from AJAX. The controller resides on the client-side and is responsible for loading (XML) data and rendering the application using the received data, without actually reloading the page in the browser.
This means that JavaScript would be used instead of HTML/JSP to render the server data. Also, the server-side is much thinner and not really in need of any web framework (as all it does is receive messages and return XML data).

Conclusion

The principles of SOFEA seem very far away from today. There are several flaws with implementing in the suggested manor:

• The web clients (browsers) of today are not good enough to handle could have problems handling as much logic as a large web site would require (given that old IE versions have so many users, ca 70-85%)
• The client code (JavaScript) and architecture is not really mature/good enough to handle this much logic, given that it needs to be bullet-proof, easy to test etc (EDIT: unless using GWT or similar – it’s at least difficult to manage)
• Developing applications would take much more time (hence be more expensive) as more manual labour is required to render content using JavaScript instead of letting the JSP engine do it with JSP/HTML/PHP/etc

Everything points to NOT implementing it in such a manor. At least not at this time, partly because the browser/client market isn’t ready for it.

Is there an other way?

Yes, there are other solutions to the main issue; changing pages without actually reloading the container (browser).

One suggested solution could be an extension to our model in Taikai, where AJAX can be used in combination with both XML, HTML/JSP and JSON, hence giving us the possibility to smoothly serve a full JSP page using AJAX.

A brief description of how it could be solved:

• Make a JavaScript “controller” handle all URL requests to the server, in order to bind the answer to a certain action.
• Set up “View XML files” for all views that are to be loaded with AJAX. The view could look something like this:

<?xml version="1.0" encoding="UTF-8"?>
<xmlRoot>
<title>Document title</title>
<styles>
<src>/css/foo.css</src>
<src>/css/bar.css</src>
</styles>
<scripts>
<src>/js/foo.js</src>
<src>/js/bar.js</src>
</scripts>
<content id="targetContainerId">
<![CDATA[<jsp:include file="foo.jsp" />]]>
</content>
</xmlRoot>

• When returning the response from the server, the returning page would be the pre-defined XML (as per above).
• The controller parses the contents of the returned XML file and performs its magic:

1. Changing the document title
2. Loading new styles and scripts (and possibly unloading old ones to keep the page slim)
3. Updating the content element (with id=”targetContainerId”) with the provided content, which has been rendered by the JSP engine and therefore taking advantage of its power (i.e. JSTL, HTML tags etc etc).
4. Updating the browser history using hash (#) technique, allowing for back/forward movement while remaining in the same page container

The main advantages with such a solution would be:

• Allowing developers to create content using known and powerful formats, such as HTML and JSP

1. Very important in respect to time efficiency
2. Still allows for easier debugging and development
3. No need to put too much logic on the JavaScript side, i.e. creating elements etc (although it could still be done in some components, if needed/wanted)

• Still providing the user with the quicker experience of a site without (or with few) full page reloads

Remaining questions:

• Would there be any risk of memory leaks, especially in older Internet Explorer browsers? And is there an easy way of eliminating these?
• Is the support for “hash history technique” good enough in all major browsers?

References

• Presentation of a suggested full SOFEA solution with AJAX and Comet
• Discussion on a SOFEA development project
• Summary of the large “Life above…” document and subjective comments
• Comments on SOFEA flaws
• SOFEA Google Group with discussions
• Matt Raible’s views on why and why not to use SOFEA