Daniel Tell­man

Today, when you build a web­site, you have lots of choices regard­ing open source containers/platforms/frameworks and libaries. Com­par­ing them can eas­ily end up get­ting flamed for com­par­ing apples and oranges. Nev­er­the­less, I dare doing so for Alfresco Surf and por­tals (as  in JSR-168/286). :)

Our first hands on por­tal expe­ri­ences date back to 2004 when there was a lot of buzz going on, por­tals bee­ing praised as best thing since sliced bread. The main argu­ments  to build a web­site on top of a por­tal were per­son­al­iza­tion, content-aggregation and col­lab­o­ra­tion func­tion­al­ity – built in and stan­dard­ized. Some prod­ucts were ship­ping with var­i­ous “com­mon enter­prise task” portlets and wiz­ards to cre­ate a web­site quickly. Hon­estly, just as many other peo­ple, we were con­vinced por­tals will become a big suc­cess. Mean­while (just as many oth­ers) our opin­ion about them has changed a bit :)

When we looked at Alfresco Surf and Web-Studio in 2007 (Details), we found part of its approach look­ing quite sim­il­iar to the one of a portal:

• WebScriptRequest/-Response pretty much look like their port­let coun­ter­parts (although Surf does not dis­tin­guish between action and render)
• Surf page-anatomy pretty much looks its por­tal counterpart
• Surf is aware of a user entity (personalization/security)
• With Web-Studio, you can cre­ate a Surf based web­site in a point and click fashion
• Content-aggregation is eas­ily imple­mented using com­po­nent web­scripts and connectors

For us, that raised the ques­tion why Alfresco chose to “rein­vent a wheel” which is already there ?

Look­ing fur­ther, we found quite a few areas where Surfs approach dif­fers from portals

• With Surf, Web-Studio and Alfresco WCM, you have “full” web-content-management on top
• Web­Scripts are more gen­eral than portlets – then can exe­cute in diffrent envi­ron­ments (i.e. servlet-/portlet container)
• Dynamic lan­guage sup­port built in (server­side javascript) – devel­op­ment can be a breeze when you don’t have to restart the server all the time

Content-management can really cause headaches when you have a por­tal par­tic­i­pat­ing in the game (Our Expe­ri­ences). Jeff Potts sum­ma­rizes a few approaches inte­grat­ing Alfresco (w/o Surf) with a por­tal in his blog.

Was prob­lem­atic (web-)content-management sup­port (in portal-context) a rea­son to cre­ate the Surf platform ?

We did not (and still do not) know.

What Alfresco offers today is at least a solid foun­da­tion for build­ing per­son­al­ized, col­lab­o­ra­tive and content-centric web­sites. Alfresco Share is a good proof (although it does not “really” cover web-content-mangement as in pages, tem­plates, regions, com­po­nents etc.). Regard­ing its fea­tures, it could well serve as a demo appli­ca­tion of a por­tal ven­dor. :) Alfres­cos web­site “point-and-click edit­ing UI” (Web-Studio) is a lit­tle behind com­pe­ti­tion (although in some aspects even ahead), but that may change soon.

Where is the catch ?

Things can get a lit­tle cum­ber­some when you need to embed com­plex appli­ca­tion functionality/behaviour such as form val­i­da­tion, processes/flow, con­ver­sa­tions (as in con­ver­sion scope) and AJAX within a Surf based web­site. These are require­ments per­fectly tai­lored for stacks like grails or seam. Sure, it is not impos­si­ble doing this within a Surf based site, but I doubt Surf qual­i­fies as a “nat­ural choice” when you are faced with these kind of requirements.

How would one imple­ment com­plex appli­ca­tion func­tion­al­ity (i.e. a shop with order process) assum­ing you are given a Surf based site and you want to use a full-stack such as grails or seam ?

In gen­eral, I see two approaches. Make the web­site two appli­ca­tions – the “main” Surf based site and another one for the appli­ca­tion and …

• … inte­grate the appli­ca­tion using AJAX (i.e. using jquery forms).
• … inte­grate using the portal-style-cross-context approach

Of course  you can also try and make one “Surf + webapp-superstack” appli­ca­tion, but going that route, you can eas­ily end up resolv­ing library con­flicts. I’ve tried the first route using grails as the “webapp-superstack”. Surely not a golden-hammer solu­tion, but good enough to address some issues quickly and easily.

So when it comes to com­plex appli­ca­tions, por­tals seem a lit­tle ahead of Alfresco Surf, as there is a wide vari­ety of appli­ca­tion frameworks/libaries avail­able and “ready to use”.

PS: We don’t think por­tals are a fail­ure in gen­eral. Peo­ple involved with por­tals should have cared a lit­tle more about CMSs. We just think there is less rea­son­able use for por­tals than we thought there is in 2004. You should think twice before employ­ing one. Are the fea­tures a por­tal offers really address­ing your requirements ?

PPS: Por­tal + cms inte­gra­tion approaches some­times remind me of this ad sug­gest­ing things some­how don’t fit.