Tag: review

Content-as-a-Service Review: Cloud CMS

Cloud CMS LogoThe next vendor in my Content-as-a-Service (CaaS) round-up is Cloud CMS. If you missed my overview of the CaaS market, you might want to read that first.

Cloud CMS has been around since 2010. It was founded by Michael Uzquiano, formerly of Alfresco, Epicentric, and Vignette. This year they brought on a new CEO, Malcom Teasdale, who, prior to joining Cloud CMS, ran Rothbury Software, an Alfresco partner that was ultimately purchased by Ixxus. Malcom spent some time at Interwoven earlier in his career. So these two have a lot of content management experience and that’s evident in their product. (Disclosure: I’ve known Michael and Malcom for several years but I do not currently have a business relationship with Cloud CMS).

My CaaS overview described functionality you’ll find in all CaaS offerings. Similar to my posts on Prismic.io and Contentful, in this post on Cloud CMS I’ll focus on some select areas of the Cloud CMS offering:

  • User interface for content authors
  • Creating content types
  • Working with content via the API
  • Security
  • Pricing

Cloud CMS is an extensible platform with a long list of features. This is more than just a place to stick content and an API to get it back out–this is a full-featured CMS that happens to be running as SaaS in the cloud. But I’m primarily interested in it for its ability to act like a CaaS offering, which to me means a more pragmatic, stripped down approach to content management, so this review is going to ignore a lot of the Cloud CMS features that go beyond that. Perhaps I’ll come back to those in a future blog post.

User Interface for Content Authors

Before I describe the Cloud CMS user interface let me tell you a little about how Cloud CMS stores content. A Cloud CMS account has one or more repositories. How you use your repository is up to you–you might have one repository per project, for example.

Within a repository there are one or more branches. A branch works just like it does in source code control–it is a view of the repository. Each repository has a “master” branch, but you can have as many branches in a repository as you want. Branches can be areas where individuals work on content in isolation, or they can be for teams. Branches can never be deleted.

Within a branch are one or more changesets. Adding content to a branch (or making any change) takes place against a changeset–you’re never actually changing anything that was written previously.

And, finally, at the object level you have nodes. Everything in Cloud CMS is stored as a node. If you have a blog post, that’s a node. If your blog post points to an image, the image is also node. All nodes are typed. There are out-of-the-box types but you can also define your own. I’ll talk more about that in a bit.

Cloud CMS provides a web user interface that helps teams organize content creation built around the notion of projects. For the most part, your users see your repository through the lens of a project. They don’t have to understand the underlying structure of the Cloud CMS repository.

The first thing you see when logging in to Cloud CMS is a dashboard. From here you can manage your projects, tasks, members, and workflows. For my review I created a project called “My Cloud CMS Project”.

Cloud CMS Home PageDrilling into the project displays the project’s dashboard. Clicking on Documents shows a hierarchical view of folders and documents. Multiple files can be dragged-and-dropped which triggers an upload to the folder. As you can see in the screenshot below, thumbnails are automatically created and displayed in the document list.

Cloud CMS Project DocumentsClicking a specific document opens the details page for that object where users can edit the properties of the object, make comments, assign tags, start workflows, and perform a number of other actions.

Cloud CMS View Project DocumentSo that’s how content authors manage content in Cloud CMS. Let’s take a look at how the content model is defined.

Creating Content Types

Content Type definitions are created using JSON Schema. You can define types using either the Cloud CMS UI by typing your JSON Schema into a web form, or by using the API. I really like the ability to define a content type simply by typing the JSON Schema that defines it. Of course, the trade-off is that you have to know how to define a type using JSON Schema. Fortunately, there is documentation that can help.

Content modeling in Cloud CMS is much more advanced than what I’ve seen in other CaaS offerings. Three examples of that are: hierarchical content models, aspect-orientedness, and role-based form definitions.

The first one, hierarchical content model, is easy to grasp: Your types can inherit from parent types. This can potentially save you time setting up your content model if your types lend themselves to being organized in a hierarchy.

The second one requires a little more explanation: aspect-orientedness. A content model is aspect-oriented when it has the ability to define bundles of properties that can be “attached” to objects, regardless an object’s underlying type. In Alfresco these are called “aspects”, in CMIS these are called “secondary types”, and in Cloud CMS these are called “features”.

For example, you might have a set of metadata that you want to track for anything that is “client-related” like the client’s name, industry, size, and primary contact. In Cloud CMS you define that set of metadata as the “client-related” feature, and then any object can become “client-related” just by adding the client-related feature–the bundle of properties having to do with a client–to the object.

The third advanced content model-related feature in Cloud CMS is role-based forms. When you create instances of a content type, Cloud CMS looks at the schema and generates a default form, similar to how other CaaS offerings work. What’s different is that Cloud CMS allows you to define multiple forms for the same content type. You can tie forms to specific roles so that different people see different authoring forms depending on their role. This is helpful when you have different types of people who need to edit the same content–you can use role-based forms to structure the form the way it makes the most sense for each type of user.

By the way, like content type definitions, form definition is also JSON-driven. Cloud CMS leverages the open source AlpacaJS forms engine into their product, which you might want to consider for your own projects, even if you don’t need Cloud CMS.

Working with Content via the API

Cloud CMS can host your application for you. This makes it nice for people who are looking for a one-stop shop for their content-centric mobile and web applications because you don’t need separate services for your content and your app. If you look back at the project dashboard screenshot I showed earlier you’ll see an example–I’ve created an application called “demo”.

What wasn’t obvious to me initially is that even if you are going to host your application elsewhere, you still need to create an application, and within that, a deployment. That’s where you’ll find the API keys needed to work with the API.

In addition to the API keys you’ll need to know your repository ID (which you can get from the Cloud CMS admin console). If you are going to fetch content from anything other than the master branch you also need the branch ID. Once you have that, querying for nodes is straightforward, as shown in this gist:

(Can’t see the code? Click here).

Under the covers, Cloud CMS is running MongoDB and Elasticsearch. So when you query for Nodes, you’re using Mongo. When you’re searching the full-text of your nodes you’re using Elasticsearch.

Everything in Cloud CMS is stored in JSON so creating content is as simple as calling createNode and passing in JSON for the property values:

(Can’t see the code? Click here).

Security

Every object in Cloud CMS can have an ACL and child objects can inherit ACLs from their parents. There are out-of-the-box roles you can use in those ACLs, including: Connector, Consumer, Contributor, Editor, Collaborator, and Manager. Unfortunately, to set permissions on an object you have to switch from the project user interface to the administrative user interface. Still, this is the only vendor in the round-up offering object-level permissions.

Pricing

Cloud CMIS offers a free 14-day trial. After that you have to switch to one of four monthly plans:

  • Starter: $20/month. Limited to a single project and email support.
  • Platform: $200/month. Unlimited projects and email support.
  • Premium: $800/month. Unlimited projects, phone support, developer support, additional AWS features
  • Enterprise: $2400/month. Private cloud with an on-premises option

The ability to run the entire stack on-premises is an interesting option for those not ready for the cloud although I haven’t explored how practical that really is for Cloud CMS.

The usual caveats apply to pricing here. Like other CaaS offerings, Cloud CMS places limits on total storage space and data transfer so look at the details to make sure you understand what this will cost you each month.

Overall Impressions

Cloud CMS is a full-featured platform for content management. Where some startups focus on the minimum viable product, Cloud CMS has gone for a kitchen sink approach that approximates the functionality you might expect in more mature, on-premises ECM offerings. Cloud CMS can even be the platform that runs your application, if that’s what you need.

Content management professionals will appreciate the advanced content modeling and forms features, which is just one example of functionality that reflects the founders’ ECM industry heritage. The flip-side of that coin, however, is the complexity also reminiscent of those systems. The documentation and tutorial videos help but there is a learning curve here.

Cloud CMS can compete against CaaS players like Prismic.io and Contentful as well as established ECM vendors like Alfresco and Documentum. Compared to other CaaS players it has much richer functionality, but it is also more complicated to use. To compete against them successfully Cloud CMS may need to further streamline the UI so that users can harness that power without being overwhelmed by other features.

Compared to established vendors like Alfresco and Documentum, Cloud CMS offers a hosted system running in the cloud with a similar feature list while maintaining the ability to customize the platform. Customers looking to move to the cloud may find an easier migration to Cloud CMS than to one of the newer CaaS players. In this respect Cloud CMS also competes with other traditionally on-prem document management offerings now offered in the cloud like Hippo onDemand and Nuxeo Cloud.

With two ECM veterans at the helm and impressive functionality it will be interesting to watch Cloud CMS go after one or both of these markets.

Content-as-a-Service Review: Contentful

contentful-logoIt’s time for the next vendor in my Content-as-a-Service (CaaS) round-up. In this post I’ll be taking a look at Contentful. If you missed my overview of the emerging CaaS market you might want to take a look and then come back.

Contentful came out of beta to be generally available in May of 2014, so it is the youngest vendor of the three in my round-up. The company is based in Berlin and has a number of well-known clients including EA, Disney, Viacom, Asics, Nike, Playboy, and McAfee.

My CaaS overview described functionality you’ll find in all CaaS offerings. Similar to my post on Prismic.io, in this post on Contentful I’ll focus on the areas that typically differentiate one CaaS offering from another, namely:

  • User interface for content authors
  • Creating content types
  • Working with content via the API
  • Security
  • Pricing

Finally, I’ll wrap up with my overall impressions and takeaways.

User Interface

In Contentful you have one or more “spaces”. You can think of a space as a repository. It’s a collection of “entries”, which are instances of content types, and “assets”, which are file-based assets like images. In addition, each space has its own users, roles, and API keys.

When you log in to Contentful you’ll be sitting in one of your spaces (the first one in the list). The Contentful user interface is clean and quite minimal. It’s easy to get going quickly because you have a limited function set. You can define your content model, manage entries, manage assets, or manage your API keys and that’s about it.

contentful user interfaceOptions for organizing lists of entries and assets are limited to filtering based on status (Published, Changed, Draft, Archived), content type (for entries), and file type (for assets). There is a saved search feature and saved searches can be organized into folders. But, there is no notion of hierarchical content storage.

This minimalistic approach to content management is what I characterized as a Good Thing in my Content-as-a-Service overview.

Content Types

Every content management system has a way to describe the data stored in the repository which is referred to as a “content model”. In Contentful, each space has its own content model which is simply a set of content type definitions. A content type is a set of typed properties. There are property types you’d expect, like text, date, number, decimal number as well as “pointer” types that reference other objects in the system, where those objects are either entries or file-based assets.

For example, the screenshot below shows a Promo content type I created. It has a name, a description, and a set of fields such as pubDate, geoCode, image, alt, etc. In the case of the image field, it points to a file-based asset.

contentful content typeUnfortunately, there is no support for cross-cutting concerns (aspects) so if you want to repeat property definitions across types you have to do that manually. For example, a type called “Cat Picture” and a type called “Dog Picture” might both have “height” and “width” properties. In Contentful, you have to repeat similar properties across type definitions.

On a related note, there is no way to clone or copy content types in the user interface. If you have two similar content types you have to re-do the property sets in each one or use the Contentful content management API to do this.

Managing your content model in the Contentful UI takes way too many clicks. I much prefer the approach other CaaS offerings take where you edit the content type definitions using JSON rather than the point-and-click approach. The nice thing with Contentful is that you can use the API for everything, including defining your content model–you don’t have to use the UI at all if you don’t want to.

One thing to watch out for: If you want to change a field on a content type (like maybe change the type of field) you have to deactivate the content type first. That’s not such a bad thing until you realize you cannot deactivate a content type without first getting rid of the instances of that content type. This could be a challenge once you go to production, so make sure you are happy with your content model before you get too far down the road.

Working with content via the API

Content can either be “published” or “draft”. The API keys you generate for a space can either be “production” or “preview”. The production URL and access key can only fetch published content. The preview URL and access key will see everything.

The Contentful Content Delivery API lets you fetch content by space which can be further filtered by query terms that will be AND’ed together. There was not an obvious way to OR query terms.

If you’d rather, Contenful offers client libraries in Java, JavaScript, Objective-C, Swift, and Ruby.

Here is a gist that fetches content using JavaScript:

var contentful = require('contentful');

var spaceId = 'someSpaceId';
var accessToken = 'someAccessToken';
var contentTypeId = 'someContentTypeId';

var client = contentful.createClient({
  space: spaceId,
  accessToken: accessToken,
  secure: true,
  host: 'cdn.contentful.com'
});

client.entries({
    'content_type': contentTypeId,
    'fields.pageId': 'all',
    'fields.geoCode': 'all'
}, function(err, entries) {
    if (err) { console.log(err); return; }
    for (var i = 0; i < entries.length; i++) {
        var entry = entries[i];
        console.log('id: ' + entry.sys.id);
        console.log('name: ' + entry.fields.name);
        console.log('pageId: ' + entry.fields.pageId);
        console.log('--------')
    }
});
id: someId1
name: promo-3
pageId: all,page2,page3
--------
id: someId2
name: promo-2
pageId: all,page5
--------
id: someId3
name: promo-1
pageId: all
--------

(Can’t see the code? Click here.)

If all you need to do is fetch content from Contentful, you’ll stick with their Content Delivery API. To create, update, or delete content, use the Content Management API.

For example, here is a gist that creates content using the Content Management API:

var contentful = require('contentful-management');

var spaceId = 'someSpaceId';
var accessToken = 'someAccessToken';
var contentTypeId = 'someContentTypeId';

var client = contentful.createClient({
    space: spaceId,
    accessToken: accessToken,
    secure: true,
    host: 'api.contentful.com'
});

// a custom "Generic Content" content type
var entry = {
    fields: {
        name: {
            'en-US': "Take a Trip!"
        },
        description: {
            'en-US': "Title for page 4"
        },
        geoCode: {
            'en-US': ["all"]
        },
        loginState: {
            'en-US': ["all"]
        },
        pageId: {
            'en-US': ["page4"]
        },
        placementId: {
            'en-US': ["banner"]
        },
        expDate: {
            'en-US': "2014-10-31T00:00:00-05:00"
        },
        pubDate: {
            'en-US': "2014-10-01T00:00:00-05:00"
        },
        content: {
            'en-US': {title: "Take a Trip", imgSrc:""}
        }
    }
};

client.getSpace(spaceId).catch(function(error) {
    console.log('Could not find space: ' + spaceId);
    throw error;
}).then(function(space) {
    space.createEntry(contentTypeId, entry).catch(function(error) {
            console.log('Error creating entry: ' + error.toString());
            throw error;
    });
});

(Can’t see the code? Click here.)

Note that content is initially created in draft mode. You must publish the content if you want it to be retrievable via the “production” content delivery API.

I should mention that Contentful also offers a sync API, which is particularly useful for mobile applications.

Security

In Contentful, everyone belongs to one or more Organizations. Organization owners can create spaces and can invite users to a space. Users can be editors (edit all content) or developers (edit all content, manage API keys). Space admins can create new content types. The UI shows a “custom role” but this article says that custom roles will be implemented for the enterprise offering at some point in the future.

Contentful also makes it easy for agencies or consultants to administer an organization on their client’s behalf while the client remains the main contact for billing purposes.

Pricing

Contentful offers the following plans:

  • Free plan which is limited to 3 users, 3 spaces, and 1,000 objects
  • Plus plan for $99 per month which includes 5 users, 5 spaces, and 5,000 objects
  • Pro plan is $200 per month for up to 10 users, 10 spaces, and 10,000 objects.

Most of my clients would probably need the “Enterprise” plan which could cost anywhere between the low thousands to the tens of thousands of dollars per month depending on exactly what is needed.

Also, be aware that Contentful, like other CaaS vendors, places limits on additional things such as API requests, API bandwidth, and API keys. These and other details may change so take a look at the pricing page (click “Compare Plans” for the expanded details) to be sure.

Overall Impressions

Contentful is an extremely basic offering in terms of both the user interface and the capabilities of the underlying platform. But the simplicity of the offering is precisely what makes it so attractive. Developers will appreciate the “API-first” approach to content management, and without a lot of extraneous sub-systems getting in the way, they’ll be able to develop a solution quickly, and then let content authors manage the content with the easy-to-use interface. Contentful’s stripped down, pragmatic approach to content management is a category-defining building block you can use to create really cool content-centric solutions.

Content-as-a-Service Review: Prismic.io

Today I’m prismic.io logogoing to take a brief look at Prismic.io. Prismic.io is one of three commercial Content-as-a-Service (CaaS) vendors I’m reviewing as part of my CaaS round-up. If you missed my overview of the emerging CaaS market you might want to take a look and then come back.

Prismic.io was founded by Sadek Drobi, one of the co-creators of the Play framework, and Guillaume Bort, one of the Play lead developers. It launched in early October, 2013.

My overview talked about the kind of functionality you’ll find in all CaaS offerings. In this post on Prismic.io I’ll focus on the areas that typically differentiate one CaaS offering from another, namely:

  • User interface for content authors
  • Creating content types
  • Working with content via the API
  • Security
  • Pricing

Finally, I’ll wrap up with my overall impressions and takeaways.

User Interface: Let me show you to your room

Your Prismic.io account starts out with a sample repository called Les Bonnes Choses (The Good Stuff) and some sample content within that. The repository and sample content powers a sample web app for a fictitious pastry shop.

When you first log in to Prismic.io a dashboard lists the Les Bonnes Choses repository and any other repositories you’ve created. A quick side-note on repositories: When creating a new repository I was forced to pick a name no one else had taken. The repository name is used as a sub-domain under prismic.io, so I see why it has to be unique, but this seems like an odd choice for a service I’m sure the founders are hoping will grow wildly.

Anyway, clicking on a specific repository takes you into that repository’s “writing room”, which is the primary interface for not only authoring content but also configuring your repository’s various settings.

The writing room UI is certainly the most polished of any of the CaaS vendors I reviewed. While it looks great, I feel like the fly-in/fly-out animation is a bit over-used and many of the icons are un-labeled. The UI also uses colors to indicate status, but the meaning is not obvious initially.

prismic.io writing room

The overall organizational model is activity-centric rather than asset-centric. If you’ve got a team of people pushing out content in a rather flat hierarchy this will probably work well. If you like a more traditional list-of-assets-in-a-nested-folder hierarchy you’ll have to adjust. The “Live Now”, “Your Documents”, and “Favorites” help filter the list of content.

Releases provide snapshot capability

A helpful concept in Prismic.io is the “content release”. This gives you the ability to plan releases ahead-of-time. When your content authors write content they can publish it to a release. When the release is published, all content associated with that release goes live. You can control who can access to-be-published content in the API settings.

Creating content types

In Prismic.io, content types are called “Document Masks”. Document masks are defined via the Prismic.io UI by writing JSON that describes the mask. For example, here is a snippet from the Blog Post document mask:

(Can’t see the code? Click here.)

Notice that there is an object called “Blog Post” and an object called “Metadata”. These are rendered as tabs in the writing room UI. You can segment your document mask definitions however you see fit. Within the top-level object there are one or more fragments, each of which has a name, like “author”, a fieldset, a type, and a config.

Looking at the “author” config you can see that it is possible to add references to other documents in the repository. In this case the association is between the blog post and an author object. Elsewhere in the blog post example are similar links to “related posts” and “related products”.

I like that the content type definitions are expressed as JSON. It’s a lot easier to work with definitions in this way than with a UI-driven approach, especially when the content type definition language is fairly rich, as it is here.

Another nice feature of the document mask editor is the ability to quickly preview what the form will look like in writing room.

Collections and Bookmarks

Document masks define the type of documents your content authors can create. Prismic.io also gives you the ability to define collections and bookmarks.

You can think of a collection as a saved search. A collection defines a set of filters (document masks and/or tags). Content authors can then navigate to content by clicking collection names in the writing room. In fact, aside from the filters I mentioned earlier, collections are the only way to organize content.

Your front-end can use the API to get the documents matching a collection by specifying the collection name rather than building the query from scratch. I’ll show you an example of that in a minute.

A bookmark is a collection for a single document. It is kind of like an alias. Suppose you are building an app that needs to promote a “deal of the week”. The deal might change from time-to-time. One way to implement this would be to create a bookmark named “dealOfTheWeek” and point it to a document for this week’s deal. The front-end app can always ask for the same bookmark, but the object it points to can change as needed.

Fetching Content via the API

There are multiple client-side libraries you can use to work with content in Prismic.io including JavaScript, Python, Java, Ruby, .NET, PHP, and Scala. You can get more info from the Prismic.io developer page.

Here’s an example showing how to get the documents in a collection named “blogPosts”:

(Can’t see the code? Click here.)

Here’s an example getting the document for a bookmark named “dealOfTheWeek”:

(Can’t see the code? Click here.)

In the bookmark example you can see that once the document ID is fetched from the bookmark I constructed a query against the “everything” collection using the ID. This barely scratches the surface of what’s available in the query language–check out the developer docs to learn more.

One extremely disappointing thing about the Prismic.io API is that it is read-only. Yes, you read that right. Prismic.io is a content service that only lets you read content via the API, not create it.

The lack of a write API means that if you have existing content that you want to move to Prismic.io, there’s no way to do that short of hiring a bunch of temps and re-keying it into the system. Potentially worse, if your content originates from some other system and you want to use Prismic.io for delivery, there’s no way to do that either. And of course if you have user-generated content you need to persist from the front-end, you’ll have to write to some other service.

I suspect that a year from now we will all agree that a write API is table stakes for a viable CaaS offering and Prismic.io either will have fixed it or they will have relegated themselves to a microscopic corner of the market focused on tiny, greenfield, content silo projects. We shall see!

Security

By default, the API requires an OAuth token. Per repository, you can change that. For example, you might make it so that the API can fetch content from the “master” release without a key, but fetching content from future releases requires a token. Or, you can make access completely open.

Pricing

With Prismic.io, development is free. You don’t pay until you go to production. There are three paid plans available: Simple gives you all of the featues, but is limited to three users for $7/month. Team gives you unlimited users for $40/month. Enterprise gives you an SLA and a private cluster but you’ve got to negotiate pricing.

Something that’s pretty cool for all of my open source friends is that if you make your content available under the Creative Commons 4.0 license, you can use a Simple plan for free.

These plans, pricing, and details may change, so take a look at the official pricing page.

Overall impressions

The lack of a write API for programmatic content creation makes Prismic.io a non-starter for anyone having anything more than the most modest requirements, particularly in cases where there is a large volume of pre-existing content or when other systems need to write into the content store.

If you have the luxury of starting with zero content and all of your content will be created by humans using the snazzy Prismic.io user interface, then it is worth considering.

Prismic.io certainly has the most helpful developer on-ramp of any of the solutions I looked at with lots of client libraries, good examples, decent documentation, and useful starter apps. And I also liked their “free while you are developing” model, which makes it easy for teams to get started building their real solution, rather than a scaled-down PoC.

If Prismic.io puts a write API in place they’ll be a strong CaaS contender.

Review: Professional Alfresco, Wrox

I recently finished reading Professional Alfresco, the new Alfresco book written by some of the Alfresco engineers and John Newton, Alfresco’s CTO. Before I share my thoughts, a few disclaimers: First, I wrote my own book on Alfresco called the Alfresco Developer Guide (Packt, 2008). Second, Wrox provided the book to me free of charge in the hopes that I’d write something about it here. Third, I have a strategic relationship with Alfresco, part of which includes bringing each other business.

Okay, with that out of the way, let’s get to it. Professional Alfresco is a new book written about Alfresco 3.2 by a team of authors with a unique insider perspective: all are Alfresco employees. It’s not an end-user focused book nor is it strictly for developers–it’s actually aimed at several different audiences:

  • Part 1, “Getting to Know Alfresco”, is aimed at IT managers or other folks who might be evaluating Alfresco. It covers the business benefits of Alfresco and provides a high-level overview of the platform.
  • Part 2, “Getting Technical”, looks at the platform’s components and services at a closer level. These chapters are directed at Technical Architects or anyone who’s trying to figure out the technical capabilities of Alfresco.
  • Parts 3 & 4 are aimed squarely at Developers. More specifically, these 6 chapters cover Web Scripts (primarily JavaScript, but a Java example is given) and Alfresco Share. The last 3 chapters of Part 4 provide a step-by-step example of building a Knowledgebase application by customizing Alfresco Share, including a few (brief) pages on the new Form Service. A lot of people are working on Share customization projects these days so many will find this a welcome set of material.

While the majority of the technical how-to in the book is focused on Web Scripts and Share, I particularly liked the chapter on Advanced Workflows. It did a good job of explaining what you can do with the jBPM engine without getting too far into the weeds. The section on the Authentication subsystem, LDAP config, and chaining was also very good, particularly as the subsystem setup is a fairly recent development that not everyone is familiar with.

While I did find a lot to like about the book, there were a few things to pick on. First, if you read the book front-to-back, you’ll notice a significant amount of repetition. I suppose that could be a good thing when one of the three audiences the book is written for picks up the book and goes directly to their area of interest. I wonder, though, if some of it was due to having so many authors collaborating on the writing project. The repetition left me feeling like I was really slogging through the material rather than cutting to the chase.

I thought the content modeling chapter was thorough, but I had to wonder why the author chose to step us through the modelSchema.xsd file instead of providing example content model XML. It’s good to know the content model schema is there if I need it, but I think examples of what I can do with the XML are far more illustrative than walking through the schema.

The form service and Share/Surf aren’t covered in nearly enough detail. Other aspects of the platform simply aren’t addressed at all. I think some of that may be because of timing. The form service, for example, continues to evolve with version 3.3, and when you undertake a project this big, you have to draw a line somewhere. Plus, the focus on web scripts and Share is aligned with where Alfresco is focused right now.

The organization of the book is good. It follows a logical progression through the platform. And I like that the end-to-end Knowledgebase example is placed at the end as a sort of capstone applying the concepts learned earlier in the book. If you’re looking for a tutorial-style book though, you may be frustrated by the amount of theory up-front. It’s just not that kind of book. One side note on organization, Chapter 17 is a bit of an odd duck. It’s got interesting content–the chapter discusses various patterns of Alfresco implementation and integration with other systems. I just thought it was weird that it was at the end of the book instead of in one of the first two parts. Not a huge deal, and I’m glad they included it, even if its placement makes it seem like an after-thought.

Overall, Professional Alfresco is a good book appropriate to several different types of readers. Even though there were several authors that wrote it, other than the repetition issue I noted, I didn’t feel like the transitions between authors were very noticeable–the editors did a great job stitching everything together and making it seem like one voice.

The bottom line is that if you are evaluating Alfresco and are trying to understand the architecture of the platform, or if you are a developer focused on web scripts and Share, you’ll find this book to be a valuable resource.