open source web content management in alfresco

Open Source Web Content Management in Alfresco

…………………………………………………………………………………………….… Release 2.0 September 2009 Seth Gottlieb, Content Here, Inc. …………………………………………………………………………………………….… © 2009 All rights reserved. Content Here, Inc.

Open Source Web ContentManagement in Alfresco

Seth Gottlieb

Single Product ReviewVersion 2.0

Copyright © 2009 Content Here, Inc.All Rights Reserved. Not for Redistribution.

License Agreement and Disclaimer

Workgroup LicenseThis report is licensed under a "Workgroup License" that allows your company to make this report available to upto ten (10) staff members. It may not be shared with customers or copied, reproduced, altered, or re-transmittedin any form or by any means without prior written consent. Any rankings or scoring information may not be used inpromotional materials.

DisclaimerThis report is intended to be an overview of the technologies described and not a recommendation or endorsementof a specific platform or technology strategy. The most appropriate platform for your use depends on the uniquerequirements, legacy architecture, and technical capabilities of your organization. Content Here, Inc., cannot ensurethe accuracy of this information since projects, vendors, and market conditions change rapidly. Content Here, Inc.,disclaims all warranties as to the accuracy or completeness of the information in this report and shall have no liabilityfor errors, omissions, or inadequacies in the information presented.

Credits and AcknowledgementsCover design and page layouts by LAC Design

XLST work by Patrick Liddy

OPEN SOURCE WEB CONTENT MANAGEMENT IN ALFRESCO | VERSION 2.0 | SEPTEMBER, 2009 2

© 2009 Copyright Content Here, Inc. | All Rights Reserved. Not for Redistribution. | www.contenthere.net

Alfresco Enterprise 3.1 WCM

ABSTRACT

Alfresco Enterprise is considered a true Enterprise Content Management(ECM) platform because of its capabilities in all the disciplines of contentmanagement: Document Management, Digital Records Management, DigitalAsset Management, and Web Content Management. Similar to other ECMproducts, Alfresco sees its value in bringing together and harmonizingcontent across an organization, not for its excellence in any one area. Also,consistent with its ECM industry peers, the Alfresco solution is expensive.While there is a free "Community Edition," it contains experimental featuresand neither Alfresco nor its partners will support it. Customers that usethe Enterprise Edition can expect to pay between $20,000 and $50,000 inmandatory annual subscription fees.

The underlying philosophy behind the product is to provide a powerfulcontent repository and a robust application programming interface (API)for building content-centric business applications. Alfresco delivers verywell on this promise. Alfresco's repository supports advanced functionality(such as user sandboxes, event based content rules, and virtualization)historically seen only in upper tier commercial software. Recent releasesof Alfresco have introduced more elegant and powerful APIs and a newframework, "Surf," for building content enabled web applications. Alfresco isparticularly attractive to architects building unique, custom applications. Theresulting solutions tend to employ elaborate architectures and hefty helpingsof custom code which are sometimes overkill for the business problems theyare trying to solve.

Over the past year, the Alfresco team has been pursuing the knowledge-worker collaboration market that was exposed by the success of SharePoint.Indeed, most of the software company's engineering bandwidth is focusedon its new "Share" application. Like SharePoint, Alfresco's support fortraditional web publishing has been neglected. While the underlying APIsare available, Alfresco's user interface is clearly not designed for use as astand alone, best of breed web content management system. In fact, manysystems integrators build their own contributor user interfaces using usingWeb Scripts, Alfresco's highly productive server side scripting interface.



PROJECT SUMMARY

Table 1. Alfresco Enterprise Project Overview

Website: http://www.alfresco.com

Project Inception: 2005. WCM launched in 2007.

Current Version: 3.1 since April 2009.

Project Type: Commercial: tiered product model.

Licensing Options: GPL with a FLOSS exception. The Enterprise Editiondistribution requires an annual per CPU subscription($15,000 - $20,000) to use.

Geography: Alfresco Software Inc. is headquartered in the UK withsome staff distributed across North America. The usercommunity is global with concentrations across Europeand North America.

Common Uses: Repository services for custom web applications.

Sample Customers: Activision uses Alfresco to manage marketing sites for itstitles.

Two Harvard Business School Publishing sites run onAlfresco WCM.

Travelocity uses Alfresco to manage thousands of white-label travel sites.

British Telecom uses Alfresco WCM to manageconfigurations and content for co-branded customer sites.

Frameworks andComponents:

Apache MyFaces, ehcache, FreeMarker, Hibernate, jBPM,Lucene, OpenOffice, Rhino, Spring, Velocity

Integration Standards: JSR 168, JSR 170, WebDAV, Common Internet FileSystem (CIFS), CMIS

Java Support: 1.4 through 1.6

Application Servers: Tomcat, JBoss, Websphere

Databases: MySQL, Oracle, MS SQL Server



HISTORY

Alfresco is a generously funded software company with a commercial enterprise softwarepedigree. The company was founded by John Newton (co-founder of Documentum) andJohn Powell (former CEO of Business Objects) and they have rounded out their teamwith senior people from Novell and Interwoven. The fact that the early team came fromDocumentum is clearly visible in the product with its early focus on document management,repository services, and access control. Development of Alfresco started in January 2005and the team has made tremendous progress in both building the software and visibility forthe company. Alfresco describes itself as the first and leading open source ECM product— a claim that frustrates companies like Nuxeo whose ECM products pre-date Alfresco.While Nuxeo was there first, few can argue with the fact that Alfresco has put open sourceon the map as a viable alternative to commercial ECM products. Commercial vendors andopen source projects alike have adjusted to Alfresco's market disruption. Nuxeo ported itsECM product from Zope to a more familiar Java/JBoss platform. Commercial vendors arereconsidering their pricing and value propositions.

Alfresco has been iterating on its licensing and business models since the first publicrelease of the software. The company has a strong moral stance that those who useAlfresco's software should pay for it. In an effort to convert users into paying customers,Alfresco has dabbled in tiered products with different features and badgeware versions.However, their strategy has been getting progressively more open source friendly. Thecurrent approach is a single code base for both the Community and Enterprise tiers. Bothproducts are licensed under the GPL. The Community Edition, also called "Labs," is lessrigorously tested and contains experimental features that may or may not make it into theEnterprise Edition. Customers are advised against using the free Community Edition foranything but experimental uses; the Community Edition is neither supported nor patched.There are features in Community Edition that will never be incorporated into the Enterpriseproduct. Certified integration partners are forbidden from working on the Community Editionfor their clients. It is possible that one day a community will form to support the CommunityEdition but as of today none exists, and it is doubtful that the Alfresco team will encourageone.

Alfresco's drive into the WCM space did not start until the beginning of 2007 whenit recruited Kevin Cochrane and other thought leaders from Interwoven. This was apromising sign that the former Documentum team recognized that their limited web contentmanagement vision could not compete against the best of breed WCM platforms. Thereseemed to be great promise for Alfresco as a capable web content management system.WCM was officially launched with release 2.0 of the Alfresco Community Edition in July2007; first WCM customers launched in August. They tended to use the product for ethervery simple static websites or for managing and deploying XML files in complex customarchitectures. Based on published reports and customer counts there appears to bebetween 300 and 350 out of 1,0000 paying Enterprise Edition customers currently usingAlfresco WCM.



The first couple of releases of Alfresco WCM are now universally acknowledged to havebeen a rush job. Many of the systems integration partners claimed WCM should havebeen positioned as Beta quality prior to the 2.2 release when critical functionality (likesearch) started to be exposed through the user interface. Version 2.2.3 made up for pastsins by addressing a majority of the bugs and set the stage for the current 3.x series.Still, the latest release, 3.1, has introduced no significant end-user functionality and hasprimarily focused on putting in place better testing facilities, refactoring the code base, andaddressing performance issues.

Over the last year, pure web content management has taken a second seat to SharePoint-style collaboration functionality. The first indication of this was in June 2008 when theWCM team Kevin Cochrane, Jon Cox, and Britt Park (all Interwoven alumni) left thecompany. This led to a tighter focus on the document management and collaborationcomfort zone that the original team had at the start. The WCM team was replaced byMichael Uzquiano, who was promoted from the role of sales engineer and, to this day, isnot listed on the Management Team page of the Alfresco website. Michael spends nearlyall of his time working on the "Surf" web application framework which is designed primarilyto support Alfresco's SharePoint killer "Share." Alfresco's web content managementfunctionality still has plenty of room for improvement, but it is unlikely that addressing thesedeficiencies will take priority over functionality aimed at "Enterprise 2.0" and knowledgeworker collaboration. That said, the foundation is there for capable systems integrators tobuild highly specialized custom web content management solutions on top of the Alfrescoplatform. There are some interesting examples of companies using Alfresco WCM tomanage XML configuration files and content snippets for custom built web applications.However, this may not be the best use of such an elaborate and feature rich technologystack.



ARCHITECTURE

Alfresco gets the attention of software architects and Java developers for its standardssupport and its use of popular open source components and frameworks. The first thing younotice when you download Alfresco is that it is a lot of software. The lib folder is packedwith 149 JARs totalling nearly 71 megabytes; that is a lot even by Java standards. Alfrescoincludes some of the most modern and elegant open source components and frameworksaround. In some ways, you can think of Alfresco as one big supported bundle of best-of-breed open source software projects. Reusing these components is what has enabledAlfresco to develop their product so quickly and stay current with the latest technology andstandards.

Figure 1. Alfresco Architecture Diagram

Alfresco has a very open, service-based architecture that supports a number of standards. Source: Alfrescodocumentation site.

Alfresco's standards support and openness makes it very effective for integration withother systems and for use in service oriented architectures. When Alfresco first hitthe market, it was positioned as a framework for building any kind of content centricapplication and the user interface was merely an example of what you could do with theplatform. Today, many architects still look at Alfresco as an ideal building block for largerarchitectures. In some cases, Alfresco WCM has a role as small as simply managingand deploying XML configuration files. Java, PHP, and Web Services APIs expose allof Alfresco's functionality. The repository is accessible over WebDAV, Common InternetFile System (CIFS), and FTP. CIFS support (which allows a Windows user to map a letter



drive to the repository as if it was a Windows file server) is one of the Alfresco team'sbiggest achievements. Long time Unix users will remember what an impact that Samba[http://www.samba.org] had by allowing Windows and Unix to share files over Microsoft'sproprietary standard. Alfresco has the only Java implementation of a CIFS server. Jahia[http://www.jahia.com] includes the technology for their own content management products.One could say that CIFS is the user interface that engenders the most pride from theAlfresco team and the most adoration from business users (see commentary on theAlfresco Navigator client later). JSR 168 (the Java Portlet Standard), JSR 170 (the JavaContent Repository Standard - level 2.), and Business Process Execution Language (BPEL)are all supported. Most recently, Alfresco has taken a leadership role in developing andpromoting Content Management Interoperability Services (CMIS, pronounced "see-miss.").Alfresco produced the first implementation of the draft specification on the same day itwas announced. Alfresco CTO John Newton is an active member of the CMIS specificationcommittee.

The key to the Alfresco architecture is the repository whose node-based hierarchy is similarto the Java Content Repository. Indeed, the Alfresco JCR interface complies with level twoof the JCR specification but goes beyond the JCR baseline functionality in a number ofways. One of the more innovative features is its support of "aspects" to add attributes andfunctions across different asset types. Adding the "versionable" aspect to an asset makesthat asset support versioning; a "searchable" aspect causes the asset to be indexed.This is different from object oriented classing because it is done at the object instancelevel — the class or type of the object stays the same. Aspects are defined through XMLfiles and manually applied to content assets through the user interface or by businessrules triggered by Alfresco's event model. For example, a business user can set a rule toadd "categorizable" aspect to content when it is added to a specific folder. Although nocompiling is needed for defining most aspects, you need to restart the application serverfor them to be recognized. Defining new aspects is a convenient way to add functionality tothe system. A developer could add a "synchronization" aspect to push updates to an assetto another system, for example. The Alfresco repository also has an event model that cantrigger the execution of code on events such as update, move, or a change in workflowstate.

The Alfresco Repository is composed of three core services: the Node Service, theContent Service, and the Search Service. Together, these three are called the "FoundationServices." The Node Service manages the metadata of content objects or "Nodes."Alfresco's definition of Node maps directly to the JCR definition. Every content asset isa node placed in a hierarchical tree. Node metadata information is stored in a relationaldatabase (MySQL by default, although most database platforms are supported thanks to aHibernate object relational database layer). The Node service is used for organizing andbrowsing content. Every content object in Alfresco is stored in a file: XML for structuredcontent, HTML or native binary formats for everything else. These files are managed bythe Content Service which takes care of things like retrieving the proper version of theasset and encapsulates the mechanics of persistence. The Search Service uses Lucenesearch indexes that are stored on the file system and are also used in the on-board searchfunctionality and for listing operations in display templates.

http://www.samba.org

http://www.samba.org

http://www.jahia.com

http://www.jahia.com



Figure 2. Alfresco Architecture Diagram: Repository Services

Alfresco's repository architecture is based on three core services: Node, Content, and Search. Source: Alfrescodocumentation site.

Additional services may be added to the Alfresco repository by registering them with theRegistry Service. All the other repository functionality is built on top of these three services.This includes: Content transformation and image manipulation, metadata extraction,templating, classification, versioning, locking, workflow, and permissions.

Alfresco's early focus on the repository has made it functionally rich but also very denseand complicated. One of the primary areas of refactoring is to pull certain services out ofthe repository layer to make it leaner and cleaner. For example, the Web Scripts engine isbeing pulled into its own tier. This will make the platform more flexible and maintainable, aswell as more efficient for performance purposes.

When Alfresco introduced WCM into the architecture, they needed to make some majorenhancements to the repository. A key change was the development of the AlfrescoVersioning Model (AVM). Like with the original Alfresco repository, every asset is managedas a file. In the case of structured content, it is an XML file. The AVM goes beyondthe document management (DM) repository with functionality like file-level branching,snapshots, and directory level versioning. There is also the construct of "transparencies"that allow one collection of assets to be "overlaid" on another collection to create aview that is the union of the two collections. Where both collections have the same file,the overlaid version is shown; when the overlaid collection has deleted a file, the file isremoved from the view. It is this architecture that enables the sandboxes and snapshotsthat are explained in the content contribution segment of this evaluation.



The AVM has a distributed repository model where multiple repositories can run virtually ona single instance of Alfresco or on multiple Alfresco instances. Content can be replicatedbetween repositories and the process is identical for repositories running on the sameinstance or for repositories distributed across the network. Replication is based onsnapshots that are automatically taken every time content is pushed to the content stagingworkspace. When replication is initialized, the source repository asks the target repositoryfor a hash of its latest snapshot. The source server then sends over the files that havechanged along with the hash of the replicated snapshot (to save the target server thework of computing the hash of its snapshot). This model reduces the amount of traffic overthe network and the amount of workload on the target server that is expected to be busyservicing web traffic. A similar architecture is available for simple file system deployments.In this case, a lightweight daemon is installed on the target server rather than a full blownAlfresco instance.

The AVM sits alongside the original DM and is used for "web projects" (a web projectis a special kind of folder that contains a website). The initial vision was that the twosides would eventually merge. However, since the departure of the team that designedand evangelized the AVM, ambitions have been much more measured. A few communityinsiders even speculated that the AVM would be retired without the passion of its initialcreators. That has turned out not to be the case now that the AVM is a critical componentof the Share and Surf platforms. The new goal seems to be interoperability between thetwo repositories. The general pattern is to manage complex content assets in the AVMbut publish them out to the DM for rapid access. This is not unlike publishing out to a de-normalized database for performance purposes.

The AVM does have limitations that Alfresco is not actively addressing. The primary issueis performance. For rapid access, Alfresco recommends using the DM repository. TheAVM side is also missing some critical features. For example, permissions can only begranted at the web project level — not on a folder within the web project. Web projectsdo not support the features like a rules engine and localization that are supported onthe document management side. For a very good comparison between the AVM and DMrepostories, see Jeff Potts' article "Understanding the differences between Alfresco’srepository implementations" [http://ecmarchitect.com/archives/2009/08/31/1038]

http://ecmarchitect.com/archives/2009/08/31/1038





Figure 3. Alfresco Screenshot: Web Content Properties

Web Projects expose a small fraction of the repository functionality supported in the rest of the application.

Web projects can be accessed through CIFS (as opposed to the ECM standard repositorythat is accessible over CIFS, WebDAV, and FTP) under a separate mount point than thegeneral ECM repository. Under the WCM mount point, the user will see two directories:data and versions. Under versions there will be directories for v0 through vn — one foreach snapshot taken of the repository. This structure allows you to "time travel" to differentread-only views of the web project's repository through Windows Explorer. Other mountpoints can also be defined based on filtered views of the repository. There are some pre-defined ones that restrict what a user can see based on role. Other mount points can bedefined through XML configuration files. Despite the fact that web projects are accessiblethrough CIFS, Alfresco does not generally recommend business users accessing the webprojects in this way. It is considered safer to have them work in standard ECM projectspaces and use rules to push content into web projects.

Early in 2007, Alfresco created publicity around their JCR benchmark tests and claimed tobe the fastest open source JCR implementation (faster than the other: Apache JackRabbit).They had a platinum partner certify the results. However, the JackRabbit configurationwas using the default file system persistence rather than the much faster relationaldatabase persistence that most non-demo implementations of JackRabbit are configuredwith. Still, the definition of a benchmark was a great contribution to the overall contentmanagement software industry. The Alfresco repository (the WCM version in particular)is probably not as fast as an optimized relational database. Most Alfresco powered hightraffic websites deploy rendered content to a farm of web servers or publish XML for accessby custom delivery tiers. Repository performance is getting better and is expected to



continue to improve. A big step in the right direction came in 2.2.3 when better testinginfrastructure was introduced. The new testing harnesses and other facilities have alreadyexposed performance sapping bugs. The authoring environment of Alfresco's new Shareapplication sits on top of the WCM services so the AVM will benefit from at least some ofthe investment that is going into Share.

Alfresco is working on a trimmed down "web delivery runtime" that leaves out componentslike the web client and services like workflow, access control, auditing, security, versioning,and validation. This "Headless Alfresco" would be ideal for high-performance clusteredenvironments where a fully functional "management instance" of Alfresco publishesto a cluster of performance optimized runtime instances. The licensing cost of thesecomponents has yet to be determined. Presumably they will be less than the $15,000 to$20,000 per CPU per year subscription fees that Enterprise customers pay for the fullproduct.

Figure 4. Alfresco Architecture Diagram: Web Delivery Runtime

The Alfresco Web Delivery Runtime is a trimmed down instance of the Alfresco application that provides repositoryand other services for custom web applications.



CONTENT CONTRIBUTION

As mentioned earlier, when adding web content management functionality, the Alfrescoteam put a lot of thought into working with structured content and handling concurrencybetween multiple content contributors. Many of the ideas came from the WCM team'sbackground at Interwoven. Alfresco followed Interwoven Teamsite's approach of creatinguser "sandboxes" where users can edit and preview content without interfering with otheruser sandboxes or the production site. Changes made in a sandbox are only visible in thatsandbox until checked back into the staging sandbox. Unedited content in a user's sandboxis automatically updated to reflect changes other users submit to staging. Depending onthe user's permissions, he can directly check in an update to the staging sandbox or initiatea workflow that will collect the necessary approvals. Now in 3.1, nobody, not even anadministrator, can directly edit in the staging sandbox.

Figure 5. Alfresco Screenshot: Sand Boxes

Alfresco's sandbox model provides contributors with their own work areas to edit and preview their changes priorto checking back in.

The other Java open source WCM project to employ the sandbox model is OpenCmswith its notion of "projects." In the PHP world, TYPO3 has introduced a similar workarea concept. However, Alfresco's implementation is more sophisticated thanks to its"virtualization" technology that allows a user to browse through the site as it would appearafter the modifications are checked in.



As impressed as technologists are by the Alfresco architecture, users are often lessenthusiastic about the user interface that tries to split attention between web content anddocument management. It seems that the Alfresco team is a bit confused about the role ofthe "Alfresco Explorer" (formerly known as the "Web Client"). Originally, it was positionedas a reference application to show what one could build on top of the Alfresco platform andit seemed to get less attention from the engineering team than the programming interfacesand modularity of the system. When Alfresco positioned itself as a business applicationrather than a development framework, it was more likely to defend Alfresco Explorer. Still,when speaking to Alfresco staff, it is easy to tell from the relative enthusiasm betweenthe UI and the architecture that they see the UI as a necessary evil. It is not surprisingthat many integrators do as little with the Alfresco Explorer client as they can. At leasttwo of the early WCM implementations had contributors edit content in DreamWeaver andXML editors against a CIFS drive rather than use the Web Client, and then use Alfresco todeploy these files to the delivery environment. When going this far to work around a CMS,one should consider just using a source code control system to manage HTML files.

Alfresco Explorer is awkward and clunky in just about every way imaginable. Its useof early Java Server Faces technology creates annoying issues like a non-functionalbrowser back button and non-bookmarkable URLs. From an interaction design perspective,there are a number of problems. The primitive tree controls are not good enough for therepository's highly hierarchical structure; wizard style interfaces are inefficient for powerusers. The content editing wizard control buttons (back, next, finish) are only on the upperright corner of the page. Users need to get into a rhythm of working their way down a formand then scrolling to the top to continue on or finish the wizard.

The Alfresco Explorer is even less suited for web content management. Web sites arecreated in special folders called "Web Projects." Users need to navigate to their webprojects from the the top level of the application or via a short cut. With no tree-basednavigation or in-context editing, the web project user interface is way behind pure WCMproducts in terms of usability. Content assets are listed by their file name so a user mustguess from the file name what the content is about and then figure out what enigmatic iconwill execute the desired action on the content. The UI has a "paging style" design wherethe contents of a folder is shown in pages of 10 assets at a time. The sort columns arelimited to very basic attributes: file name, size, modified date, created date, and modifier,so it can be hard to find an asset.



Figure 6. Alfresco Screenshot: Browsing the Site

Alfresco WCM lists assets as files in a paging style interface that makes it difficult to browse through large foldersof content.

Alfresco's Web Projects have a flexible content model where all structured content isstored as XML files in the repository. Most content structures can be supported includingnested elements and links to other assets. However, there is very little control over theform that contributors use to edit the content. Form controls (editing widgets) are listedvertically on a single page. Unlike many form based web content management systems,the editing user interface has no tabs so the forms can get very long. The developer onlyhas control over the types of widget used, the name, description (help text), and order ofthe fields. There is a basic set of form controls including a calendar date selector, anda browser widget and other controls can be added. TinyMCE is shipped as the defaultWYSIWYG editors, but developers report success with other editors, as well. The TinyMCEconfiguration comes with custom browse dialogs for adding links and image references,but a surprisingly limited number of formatting buttons are enabled. More can be addedby editing a section of the web client configuration file that sends parameters over tothe TinyMCE control. Some buttons, like spell check, require the addition of plugins thatcan be easily installed (See the TinyMCE web site [http://wiki.moxiecode.com/index.php/TinyMCE:Control_reference] for a full list of configuration options). Formatting buttons canbe turned on per content type and field. For example, the summary element of a contentasset can get fewer buttons than a body element. The image and link browse controlsallow a user to browse and add new targets. The image control provides fields to set thedimensions, position, and alt text of the image. However, the browsing controls only list thefile names.

http://wiki.moxiecode.com/index.php/TinyMCE:Control_reference





One of the biggest limitations of the editing interface is the lack of direct preview. Whilethe sandbox functionality and virtualization sets the foundation for elaborate previewfunctionality, the utility and accuracy is largely implementation specific. In its native state,a structured content asset is only rendered when it is saved. This means that an editorneeds to save the asset, leave the editing interface, and then click a preview button thatwill allow him to navigate through the rendered content in his sandbox. Given that userslike to edit, then preview, then edit some more, this behavior is annoying. Many customerimplementations, however, employ custom delivery tiers which are often even moreawkwardly integrated into the solution. On some of the most problematic implementations,editors have little choice but to publish blindly and check the production site. Ineffectivepreview is particularly problematic because the editing interface itself does not give anyfeedback how the rendered asset will look. For example, one customer implementationdefined a home page as a collection of references to teasers of articles to display. Unlikeother CMS user interfaces that allow you to search through titles (and other attributes)of content to pick related content, Alfresco forces the user to browse through file names.The editor does not see what content has been associated until he saves the asset, leavesthe editing interface, and then clicks the preview button. This user interface also lacks thedrag/drop mechanism for collections that is so common in CMS user interfaces.

Figure 7. Alfresco Screenshot: Highly Structured, Related Content TypeExample

The form widgets that come with the Alfresco forms builder are not conducive to building references to othercontent. This screenshot is from a customer implementation of a home page object that references specificcontent on the site. Here you can see that the editor must know the file name of the content he wishes toassociate.

Alfresco has been dragging its feet on improving the Explorer because it sees it as a deadend, the company is developing user interfaces that will eventually replace the Explorer.As noted earlier, the biggest investment is in the Share collaboration application. Sharerejects the clunky JSF user interface model in favor of a lightweight, AJAX rich UI. LikeSharePoint, Share is a re-imagining of a portal where a user can asseble a page from



lightweight portlet-like "dashlets." Sites can have components like a document library, blog,calendar, discussion, or wiki. All of these components come out of the box and, lookingat the list, it is clear that Alfresco's focus is squarely on collaboration and user generatedcontent. From a more traditional web content management perspective, the future seemsto be with the Web Studio client (see screenshot below) that provides a drag/drop interfacefor building a website on the Surf platform. As noted earlier, developing sites using the Surfplatform is tedious and complex without Web Studio. While this user interface is critical forAlfresco's growth as a flexible website development platform, it is not slated for inclusion inany of the releases on the Alfresco Enterprise roadmap. As it stands now, the applicationis fairly buggy and quirky; it is unclear what it would take to get Web Studio to EnterpriseEdition quality.

Figure 8. Alfresco Screenshot: Web Studio

The Alfresco Web Studio user interface will be important for building more traditional websites on top of theAlfresco Surf framework. However, it is not currently ready for Alfresco Enterprise and there are no visible plansfor including it.

With release 2.1, Alfresco introduced some basic link checking functionality. Users canclick a "check links" button from within their workspace and link checking can also beadded as an automated step in the default workflow that comes with the product. This ishelpful because the complexity of the UI makes visually checking links and images a bitflakey.

Localization support is pretty weak in Alfresco WCM. A user that is familiar with the "makemulti-lingual" feature in the rest of Alfresco will be disappointed in the lack of localization



support within web projects. Companies tend to use primitive work-arounds, like appendinga locale code (en, es, fr) at the end of the file name to create localized web sites. The onlyother alternative is to manage different locale web sites in different web projects.

While earlier releases of Alfresco had a simplistic folder based workflow model, AlfrescoWCM employs a more sophisticated workflow model. Under the covers is JBoss's jBPMworkflow engine, which allows workflows to be designed and implemented visually using anEclipse plugin. On inherent limitation of jBPM is its inability to implement multiple choicelogic (see Multi-Choice workflow pattern [http://www.workflowpatterns.com/patterns/control/advanced_branching/wcp6.php]). While designing workflows is very point-and-click, it takesa little more effort to wire these workflows into Alfresco application logic. JBoss jBPM alsosupports the standards-based BPEL for cross system choreography.

When a new content type is defined, through the "web form wizard," it is associated withone or more workflows. Depending on the workflow, there will be different configurationoptions that can be selected by the user that submits the content. Workflows can initiatebusiness logic like checking links, and create manual tasks that are emailed to the user andshow up on the user's dashboard.

Figure 9. Alfresco Screenshot: Workflow Dialog

The workflow task form combines some task management plus a workflow state machine.

http://www.workflowpatterns.com/patterns/control/advanced_branching/wcp6.php





Alfresco allows a content type to be defined with more than one workflow option. Whenmore than one workflow is enabled for a content type, the user can select which workflowto use.



DEVELOPMENT, CONFIGURATION, ANDADMINISTRATION

Development on Alfresco is done at two levels. At the core application level, a developercan edit configuration files add JARs and/or use Alfresco's module system to create orreuse AMPs (Alfresco Module Packages). AMPs are encapsulated and kept separate fromthe core execution logic to ensure system stability and clean upgrades. A command linemanagement tool called MMT (Module Management Tool) installs, removes, enables, anddisables modules on the system. There is a project on the Alfresco Forge that uses Mavento build and deploy Alfresco AMPs. A developer creating a JAR or AMP has access to theentire Foundation Services through a Java API. The second level is at the presentationtier where display code like XSLT and Freemarker templates for static rendering and JSPsfor dynamic rendering are developed and managed directly in the Alfresco repository. Adeveloper can also store custom web applications (everything you would put in WAR file)in the Alfresco repository and then use Alfresco's file system deployment mechanism todeploy the application to various environments.

External application developers can leverage Alfresco's services through remote SOAP andREST APIs. One of the more exciting integration features is Alfresco's Web Scripts, whichallow the creation of a custom REST based API by coding server side Javascript code. WebScripts are a significant part of Alfresco's strategic move away from their SOAP based APIto a simpler REST API. Using Web Scripts is a very powerful way of extending Alfresco.It is particularly useful for supporting AJAX calls to provide some additional data driven,client side interactivity. Web Scripts are what enabled Alfresco to respond so quickly tothe CMIS draft specification. Now these CMIS compliant interfaces are the foundation formany Alfresco integrations with other platforms like Django, Drupal, and Joomla. The SOAPAPI will continue to be supported but it will not be expanded as the Alfresco sees RESTas the future integration standard. Alfresco Version 3.1 further improved the REST APIby exposing functionality to add users to projects, create WCM sand boxes, and submitassets.

Some systems integrators are using the native REST API extended with Web Scripts tobuild custom management and delivery applications on top of the repository and eliminatingthe use of Alfresco's clunky administration interface. As one systems integrator put it:"Alfresco is the ideal development platform for a customer that has mock-ups showing aclear idea of what they want the user interface to look like. Rather than fighting with theUI that comes with the CMS to transform it into their design, we can give them an API andlet their web developers build what they want." Alfresco is a great alternative to building acustom CMS from the ground up. They take care of all the content management specificfunctionality that most developers are not familiar with building, and leave the rest to acustom software development team.

The Alfresco team was so enthusiastic about the REST API and the potential for robustbuilding applications out of lightweight server side scripting that they decided to build theirown web application framework on top of it. The Surf framework is critical to Alfresco'sarchitectural vision.



Figure 10. Surf Based Architecture

Alfresco's architectural vision is for customers to customers to build dynamic applications on top of its repositoryusing the Surf framework. Source: Alfresco.

Today, Surf's primary goal is to support Share but it will probably be used as a keycomponent of all future business applications that Alfresco develops. Surf is built aroundfamiliar concepts like pages, page components, and templates that allow the developerto create lightweight, portal-like applications without the overhead of a clunky Java portalframework. A Surf application is deployed as its own stand-alone WAR file. Technically,Surf applications do not need Alfresco but there are a number of areas where Surf relies onAlfresco services: security, profile management, and persistence. Surf can do clever thingslike virtualized content retrieval where the same Surf instance can connect to differentsandboxes for preview and live view of an application. A Surf application can connectto multiple Alfresco repositories and other resources using credentials stored in a localrepository called a "credential vault."

As general web application frameworks go, however, Surf has the basics but is fairlyimmature. Today it only has what was needed to develop Share. Surf does not haveadvanced features like a strong security system, page flow (like Spring Web Flow), andan object relational mapping component (like Hibernate) that would make it useful as ageneral purpose web application framework. It could also use some re-factoring to simplifydevelopment. For example, Surf seems to have only partially committed to the popularphilosophy of "convention over configuration" where developers use techniques like namingconventions to avoid maintaining relationships in configuring files. Even a small Surf projectwill have loads of XML configuration files that need to managed. Large Surf projects willbe swimming in interdependent XML files. The plan is for the Web Studio user interface toautomate the creation and alteration of these files but Web Studio is part of the supportedAlfresco Enterprise product.

Probably the biggest question asked in the Alfresco community is why Alfresco did notselect a pre-existing web application framework. Maybe the Alfresco team over-estimated



how close they were to building a robust framework out of their Web Scripts technology.Perhaps they were afraid of choosing the wrong framework and struggling like they didwith Apache MyFaces on the Alfresco Navigator user interface. For now, however, manysystems integrators are finding success using Alfresco for repository services behindcustom applications built in third party web application frameworks like Spring, Struts,Django, and Drupal.

From an administrative standpoint, Alfresco web projects do not have much to offer. Accesscontrol within web projects is limited. Alfresco comes with some pre-packaged roles thatshould look familiar to a user of its document management functionality: Content Manager,Content Contributor, Content Reviewer, and Content Publisher. A Content Manager has fullpermissions on the workspace; a Content Contributor can edit and add but not publish; aPublisher can approve content but not edit; and a Reviewer can only read content. Moreroles can be created by editing configuration files. The real shortcoming of the accesscontrol model is that roles are applied at the web project level — not at the sandbox orfolder level. This makes it difficult to do things like restrict access to edit a portion of a webproject. The most practical work around is to use workflow to prevent users from publishingcontent that they shouldn't be editing. Unless approved, their edits will linger harmlesslywithin their own personal sandboxes. Another strategy would be to separate the web siteinto multiple web projects, however this would hinder sharing content across site sections.

Figure 11. Alfresco Screenshot: Managing Permissons

Managing permissions is done by inviting users and groups and assigning them roles.

Alfresco's LDAP support is based on a replication model. Alfresco periodically gets updatesfrom an external LDAP repository. This implementation is problematic if you want to edit



group memberships through the Alfresco UI because they will just be overwritten by thenext update. If you want to integrate with LDAP, it is best to do all the group assignmentdirectly in the LDAP directory or customize Alfresco to only consult the LDAP directory forauthentication.

There is currently no special back-up functionality other than to shut down the system andrun standard MySQL and file system back-up. You can also do a hot backup (when thesystem is running) as long as you back up the database before the file system. Otherwise,the database will have records of documents that are not available on the file system.While unusual for enterprise software, Alfresco's lack of a robust backup system doesnot pose a problem for most companies since the de-coupled delivery tier would remainoperational. However, for global companies working on the same Alfresco instance, havinga daily maintenance outage would not be acceptable. There has been talk within theAlfresco team about implementing a live back-up mechanism, perhaps, using the replicationfunctionality. No doubt some customers are probably experimenting with this approach rightnow.



PRESENTATION

Alfresco gives you several options when it comes to rendering structured content.Presentation templates written in FreeMarker or XSL are registered with a contenttype. Each content type can have multiple presentation templates that each make a"rendition." For example, one template could make a detailed view while another templatecould make a view to be used in a list of assets; this is good for static delivery. In orderto use Alfresco's rendering engine, content rules are set to process the presentationtemplates when the content is saved, creating rendered versions of the source XMLcontent. For example, if you have an article123.xml source file, and rendering templatesfor a detailed view and a summary view, you may get the files article123.html andarticlesummary123.html. You would also probably want to generate an index page with the10 most recent articles. The best practice is to store rendered files in a different directorystructure than the XML sources. This makes sense because rendered content should bestored as it will be navigated on the external site — not as it is managed. This also enablescontent re-use because content can be rendered to multiple places. The paths and filenames that the content is rendered to are configurable via rules that can use variables andinformation about the content to determine where to put it. One could use a taxonomy torender content into various folders; alternatively, Alfresco can be configured not to renderthe content and instead save it as XML and have a dynamic delivery tier do the renderingwhen the assets are requested.

The pioneers that built the first Alfresco powered web sites went with a static HTML deploymodel where rendered HTML files were deployed to a simple web server. This modelis particularly appropriate for sites that have been statically imported into Alfresco andare edited as HTML files rather than structured data. Other models include structuredpublishing of XML files or publishing a whole web application content, code and all.



Figure 12. Alfresco Architecture Diagram: Static Deploy Model

The simplest delivery model is static deployment where static HTML files are pushed over to a simple web server.

The big trend among Alfresco customers and integrators is around building custom activedelivery tiers. As mentioned earlier, Surf is emerging as a web application frameworkand integrators are having success using third party frameworks such as Struts, JBossSeam, and Django. Alfresco, with its robust repository and open architecture, fits nicelybehind presentation tiers. That said, when Alfresco is used in this way, there is a tendencyfor the resulting solution to get more complex than is warranted. The area where thesesolutions get particularly complex and messy is in content preview. Unless you are tryingto build a truly unique web application, it may be more efficient to select a platform with itsown, built-in presentation tier. Eventually, Surf will probably play that role in the Alfrescostack but until Web Studio stabilizes and incorporated in the Enterprise distribution, itis not there yet. The other limitation with this architecture is that the editorial interfaces(particularly those provided with Alfresco Explorer) are not good enough to make contentcontributors appreciate the role of Alfresco in the architecture. The cost of developing acustom delivery tier and a custom content contribution interface on top of the Alfresco'srelatively expensive software costs (see the delivery and support section for details) makesAlfresco an extremely expensive solution.

One of the more ambitious concepts that came over from the Interwoven engineersis "virtualization." Unlike TeamSite, which proxies over to a web server running thepresentation tier, Alfresco is provides a container for any "well behaved" (Alfresco's words)Java web application to run in. This allows both code and content to be tested in safevirtual instances running on one instance of Alfresco. In recent months, however, theemphasis on virtualization has been significantly reduced. Most Alfresco implementationsinstead use remote test servers. Alfresco can deploy content to these servers and then



proxy requests for preview and content staging in essentially the same way that InterwovenTeamSite works. To make this happen, test server instances need to be set up beforehandand registered with Alfresco. Since there is a finite number of test servers, only a finitenumber of people can preview at the same time.



DELIVERY AND SUPPORT

Alfresco is not a community project; the code base is very tightly managed by AlfrescoSoftware, Inc. During its first couple years, the Alfresco engineering team moved veryquickly to build the platform. Features were being defined and added so quickly that itwas often difficult to determine what was supported and what was planned. While thedevelopment velocity was impressive, hasty design decisions were made and bugs werenot addressed. Documentation and support struggled to keep up. All this is fairly typical fora startup software company, but the marketing message positioning Alfresco as a betterDocumentum at a fraction of the price made the customers expect more. There was quitea lot of frustration with broken or incomplete features, particularly in the WCM side of theapplication. Over the last year, however, Alfresco has pulled back from its frantic pace ofadding new features and focused on improving performance, fixing bugs, and refactoringthe code base. This should make everyone's lives easier.

While the development has adopted a more controlled and conscientious pace, the productroadmap is still murky and confusing with parallel development paths for Communityand Enterprise. It is not always clear what features in Community will get into Enterpriseand, if so, when. This frustrates customers who buy the product on planned features —particularly larger customers who feel they should be getting preferential treatment from thevendor.

The Alfresco external developer community has been steadily growing. Systems integratorswere lured into the partner network with all the visibility the product was getting.External programmers have been contributing extensions on the Alfresco Forge [http://forge.alfresco.com/]. As of August 2009, there were 205 hosted projects ranging fromlanguage packs to Outlook plugins. With Share and Web Studio, Forge will become a morecentral part of the offering. Users will be able to download and install modules available onForge from within the administrative UI much like WordPress administrators can downloadan install plugins.

The Enterprise Edition is distributed as a compiled binary that has been fully tested. Inorder to use the Enterprise Edition, customers must pay an annual "network fee" between$15,000 and $20,000 per CPU depending on the support service level agreement. Networkfees for backup and staging CPUs are cheaper but it is not uncommon for a customerto pay $50,000 per year to use the software. If the customer stops paying the networkfee, it must stop using the software. This is unlike commercially licensed software wherecustomers have the option to discontinue their support and maintenance agreements. This,coupled with the fact that most Alfresco based solutions are complemented with a lot ofcustom software, makes this an expensive platform.

The documentation and support forums are hit or miss and Enterprise customers reportthat paid support is not much better. Munwar Shariff's book Alfresco, Enterprise ContentManagement Implementation is a useful introduction to the user interface, the architecture,and its customization points. The Alfresco Developer Guide, by Jeff Potts goes intomuch greater depth in customizing and extending Alfresco. Although it is based on a

http://forge.alfresco.com/





combination of Enterprise 2.2 and Community 3.0, Jeff has been keeping the source codeexamples up to date on his website ECM Architect [http://ecmarchitect.com/]. The most upto date resource is the wiki, but the articles are not as thorough as more formal productdocumentation would be. There are a few articles on best practices, but not nearly enough.Alfresco delivers training at its offices near London and through partners elsewhere.Customers report that the training is useful.

The best bet for getting the most out of Alfresco is to go through a systems integrator whomay have an inside line on the product. Alfresco operates a network of SI partners. Thenetwork is tiered (Platinum, Gold, and so on) and based on company size and financial(and other) commitments made by the systems integrators to Alfresco — not by the amountof Alfresco work that the systems integrators do. The best way to evaluate SI partners isto look on the forums. The good SIs are the ones that are answering the questions andpublishing modules on the Forge.

Paid professional support gets low marks from customers, especially those customersaccustomed to working with large commercial enterprise software vendors. The perceptionis that the support organization is small and inexperienced. Support requests are frequentlyanswered with a naked link to a sparse and barely relevant piece of documentation.This, coupled with the price, has frustrated customers who are forced to maintain theirsupport contracts by the terms of the Enterprise license; they can't discontinue support andmaintenance even if they feel like they are not getting value from the service.

http://ecmarchitect.com/

http://ecmarchitect.com/



CONCLUSION

Table 2. Alfresco 2.2 Summary

Category Score Explanation

ContributorNavigation

While the hierarchically organized content repository canhandle large volumes of content, the Web Client is notoptimized for managing web content. It is so weak thatcustomers prefer using the CIFS interface to navigate therepository as a simple file system.

Structured Content Structured content types are edited through autogenerated web forms. There is not much control over thegenerated forms other than the form widgets used and theorder of the fields. The layout with the save buttons on thetop is awkward on long content forms. Preview from theediting interface is a key missing feature.

ConfigurationManagement

Developers have the option of using an external sourcecode control system or using the repository for versionmanagement. Virtualization is useful for spot testing code.New deployment functionality makes it easier to deploycode and content to the delivery tier.

Customization Layerand API

Alfresco is very clear that its customization layer and itslicensing prevents users from re-compiling any of the corecode. Customization of Alfresco is done through writingpresentation templates, developing modules (AMPs), andadding jars that override default behavior. The Spring IoCcontrol framework allows you to wire in code.

Delivery TierFlexibility

Alfresco does not come with its own delivery tier.Developers can use its Freemarker or XSLT engine totransform XML content when it is saved for static contentdelivery. Most customers build their own dynamic deliverytiers that either read XML deployed to a file system orfrom the Alfresco repository. The PHP and REST APIs arealso useful for building dynamic delivery tiers. Alfrescoalso allows you to virtualize and deploy your presentationtier code.

Widely UsedTechnologies

Alfresco is a Java programmer's dream. It uses all thetechnologies that a developer either knows or wants tolearn.

ProjectTransparency

Sometimes communication is open and candid,other times it is more marketing hype. The version

numbers between the Labs and Enterprise versionsare often confusing. To get the best access to



Category Score Explanation

information, work with a good systems integrator,read the wiki, and get to know other customers.

Books Alfresco Enterprise Content Management by MunwarShariff. Useful as an introduction to the platform but doesnot cover WCM or many advanced configuration andextension topics. A better book for developers is JeffPott's Alfresco Developer Guide.

Online Doc The formal documentation has adequate coverageof some of the primary topics. The wiki has a lot ofinformation but it is not particularly well organized. Bettersearch would tie everything together.

User Forums The online forum is monitored by Alfresco staff. Still,responsiveness is just average. Paid support, however, isnot much better.

Key: Nonexistent; Below Average; Average; Above Average; Exceptional.

Alfresco is an ideal platform if you really want to build your own CMS but don't trustyourself to get versioning, deployment, and workflow right the first time. The strength ofthe product is in the architecture, the APIs, and the repository; certainly not in the userinterface. Alfresco provides a higher starting point than a naked JCR implementation likeJackRabbit, but comes at the cost of some lock-in. Alfresco customer implementations tendto involve elaborate architectures with lots of integration and custom code. Because of thehigh subscription fees and the amount of customization, the cost of these solutions tends tobe higher than average for open source and mid-market commercial software.

These solutions often look more elegant in Visio diagrams than they do from theperspective of the business user. When Alfresco WCM replaces home grown solutionsor statically managed websites, the Alfresco user interface is a step up. Also customersthat are happily using Alfresco for document collaboration are finding success when theyexpand their use of the product to manage a small, simple, static website. However, whencompared to pure WCM platforms, the Alfresco user interface is noticeably lagging. Themore mainstream and free-standing a website is, the less appropriate it is for AlfrescoWCM. In settings where a strong development team is building a unique content applicationthat would require mangling a traditional WCM product, Alfresco is a more natural fit— particularly when the custom application involves significant document collaborationfunctionality.

The next phase of Alfresco's evolution should be to mature as a business application anddeliver a more compelling offering to business buyers. This seems to be the intent withShare. There seems to be less attention to creating a similar solution for web publishingand, given the makeup of the team, web content management will continue to be no morethan an aspect of enterprise content management.

open source web content management in alfresco

Documents

web delivery

custom web

simple web

web content

web application

web project

xml configuration

alfresco architecture