I used this recently to query the state of an Open Office process and then to restart the Open Office converter. It worked great.

JMX is only available in the Enterprise version of Alfresco.

People are always curious about the bike. Other cyclists chat me up, pedestrians shout questions at me as I ride by, and one couple in a car even pulled out a camera and snapped a bunch of pics while we sat at a light. I have seen other recumbents in the ‘hood and on large organized rides, but they are a very well kept secret around here so the bike tends to get noticed.

To celebrate my Bacchetta-versary, I’ve compiled a list of the most common questions I’ve been asked about the bike over the last year. Maybe it’ll motivate you to give one a spin the next time you’re at your local bike shop.

“What is that thing?”

It’s a recumbent bicycle. It’s called a recumbent because you ride in a reclined or semi-reclined position.

Recumbents come in all shapes and sizes. There are Long Wheel Base (LWB) models where the front wheel is in front of the pedals and Short Wheel Base (SWB) models where the front-pedals are above or in front of the front wheel. There are some with Above-Seat Steering (ASS; seriously, that’s what they call it) and Below- or Under-Seat Steering (BSS/USS). Many recumbents have a standard-sized wheel in the back and a smaller wheel in the front. Others have the same sized-wheel front and back. There are tandem recumbents. There are recumbent tricycles. There are tandem recumbent tricycles. It is unbelievable how many different styles there are, with significant differences in application (heavy loads, long-distance rides, racing), performance, and cost.

My bike is a Bacchetta Giro 26 (ba-KET-a is the Italian pronunciation, but ba-SHET-a is okay too). It’s a “high racer” with a Short Wheel Base, Above-Seat Steering, and 26 inch wheels on the front and back. The Bacchetta Giro and similar models have a unique-looking frame design: the bike essentially has only one main tube running from the rear wheel to the crank on the front-end. The word Bacchetta is actually Italian for “stick” and that name is certainly fitting when you look at the bike. I chose the Giro 26 because it is exciting to ride and looks sportier than its Long Wheel Base cousins.

“Why?”

I could try to make an argument about better efficiency or aerodynamics but that’s not why I ride it. I ride it because it’s comfortable. Try this: Sit in a comfortable chair, put your feet up, extend your arms, but keep them relaxed, and lay back a little bit. That’s what it’s like. While my upright cycling friends are crunched over, staring at their front tires, I ride reclined in comfort, my head naturally positioned to take a look around and enjoy the scenery. The other day a red-tailed hawk flew next to me for a short stretch. I don’t think I would have seen it had I been heads-down on an upright. It’s this open, laid-back style of riding that makes me want to ride as often as possible, as far as possible.

When people ask “why” the question often includes either an implied or an explicit question-within-a-question: “Is there a medical reason you ride a recumbent?” It’s funny that these bikes are so different, people assume something must have happened to you physically to persuade you to not go with an upright bike by default.

In my early teens I did long-distance rides with my father and uncle. I did Freewheel, a week-long ride across the State of Oklahoma, several times. On those rides, it wasn’t uncommon to end a 60- or 70-mile day with various sore spots–hands, ass, crotch, and sometimes knees. On Freewheel, you camp out, so heading to dinner, the shower, anywhere, usually means getting back on the bike. There were times when that was the last thing I wanted to do.

Hardcore upright cyclists will say that on a properly fitted bike with the right gear, you should be able to ride pain-free. That may be the case and to each his own. But for me, on my recumbent, pain is just not an issue. Sure, on a long ride I get tired, but nothing hurts. I’m not an athlete in any sense of the word, but I really feel like time is my only limiting factor when I’m riding my Bacchetta.

(When I first began riding the recumbent I did have some problems with foot numbness but some Specialized shoe inserts fixed that right up).

“Is it hard to ride?”

Honestly, it can take some getting used to. Starts are the biggest issue. On my Bacchetta, my pedal is 27 inches from the ground at its lowest point and 41 inches from the ground at its highest. On an upright, when you first start, your weight pushes down on the pedal and gives you enough forward momentum to get going. On a recumbent your weight gives you no vertical advantage. When starting, you have to push hard on the pedal with one foot while you get your planted foot off the ground and up to the pedal fast enough to get that second stroke in before you lose momentum and fall over. I’ve had some awkward starts and some close calls but I haven’t dumped it over yet.

Tight turns are a little exciting. Because the crank is in front of the front wheel, and because I’ve got giant size 12 feet, it is possible for my heel to come in contact with the front tire. So turns take a little bit of foresight. Even with that in mind, tight turns can be a little unsettling. I can easily turn within the width of my neighborhood street, but our neighborhood bike paths aren’t happening for me. For that reason, you may want to think twice about a recumbent if you primarily ride on tight bike paths rather than on the road.

When I first starting riding it, I found the balance to be a little twitchy. When I was really stroking, it felt like my pedaling was throwing my balance off and I had to consciously correct. Even twisting the grip shift added a wobble. Over time, my body learned to compensate automatically and now it’s a very stable, comfortable ride. When you’re on a long, flat road, maybe with a little tail wind, clipping along at about 18-20, a quiet purr coming from the wheels on the road, you’re not thinking about balance any more–you’re in some sort of recumbent Zen state.

“Is it slow/is it fast/is it hard to climb hills?”

I’m not a hardcore cyclist. I try to ride 50 miles a week, but I don’t always hit that. And I’m definitely not a fast rider. Garmin says my average speed (with stops) is about 15 mph. The Giro, a touring/commuting bike, weighs around 32 lbs, depending on seat choice and pedals. Bacchetta does offer a performance line of bikes, including the all-carbon Aero that weighs about 20 lbs and costs three times as much as the Giro. So I’m a slow rider on a heavy bike. Are you faster than me? Probably. Am I faster on my recumbent than I am on an upright? I think so, but I kind of don’t care.

Hill-climbing is a drag on a recumbent. You can’t stand up, so there’s not much to do about it other than down shift and pedal hard. At least there’s a back rest to push against. When you do make it to the top, though, the reward is oh so sweet. There’s nothing quite like flying down a hill feet first.

“Have you had any problems with it?”

The usual bike stuff. I used to throw my chain all of the time until I figured out how to adjust the derailleur. I’ve had to adjust the disc brakes a bit. From time to time, it sounds like my brake pads are dragging, but it’s intermittent. Every once in a while the chain grabs a leg hair or two, but I figure that’s a self-correcting problem.

Transporting a recumbent can be challenging. I can get it into the back of a mini-van with no problem. I’ve got a Thule roof rack with standard trays. My Bacchetta just barely fits in the tray, but the clamp that would normally hold the down tube on an upright bike doesn’t work for the Bacchetta so I bought an arm that holds the front wheel instead. I’ve seen a Thule rack with a really long tray that actually pivots to make it easier to get a long and heavy bike (like a tandem) onto the roof, which is probably what you’d need for a recumbent with a Long Wheel Base. I’ve seen recumbents on hitch- and trunk-mounted racks as well.

I bought a Garmin Edge 705 GPS cycling computer that came with a magnetic pace/speed sensor add-on. The add-on works great when the magnet on your crank arm and the magnet on your wheel spokes can pass by the same sensor. I think making that work on my Bacchetta would require some soldering, so I don’t monitor my pace and I use the GPS for speed. The included maps still made the bundle worth it, though.

“Can I ride your bike?”

If you’re thinking about buying a recumbent, you need to ride as many different styles as you can. They all feel different. And, at least when you are starting out, it helps to have someone that knows what they are doing give you some pointers and fit the bike to you.

I’m 6’1″, so I ride the “large” version of the Giro 26. Once you’ve got the right frame size, there are still several things you can tweak. The seat moves forward and backward and the recline angle is adjustable. The handle bars can be brought forward or backward and the handle bar tilt can be adjusted. Because it is so adjustable, it is a bit of a pain to let someone with different dimensions ride it. But bike shops deal with that all of the time so don’t be afraid to ask for that test ride.

“Where can I get one?”

Some bike shops specialize in recumbents. These will have the best selection and the most knowledgeable staff. For example, if you’re in the Austin area, I highly recommend a visit to Easy Street Recumbents. Mike is super friendly and very helpful. Unfortunately, there’s not a shop that specializes in recumbents here in North Texas. Shops around here tend to have a limited selection or none at all. I bought my Bacchetta at Plano Cycling and Fitness. They were great and I’d recommend them in a heartbeat.

Sometimes you can buy directly from the manufacturer. Bacchetta has that option if a dealer isn’t in your area. Also check out used bikes on Craig’s List, recumbent forums, etc.

I hate cold weather but I rode straight through winter this year. I couldn’t let it sit. I wanted to be out there, kicked back and pedaling hard. There’s something about riding that bike that I miss terribly when I don’t do it. I suspect many recumbent riders feel this way. The next time you’re about to yell, “Hey, nice bike!” at someone on a ‘bent, check to see if he isn’t already smiling.

Honestly, I thought Adobe would acquire Alfresco by the end of last year and I was surprised when it didn’t happen. They had done a big OEM deal making Alfresco part of LiveCycle and they did a gigantic Alfresco implementation as part of standing up Adobe’s acrobat.com site. Heck, Adobe even hosted Alfresco’s community event back in 2008. All small potatoes in the grand scheme of things, I know, but I can’t help but feel like the proud parent who’s daughter brought home a keeper, only to find out the guy’s been dating a hottie from Switzerland the whole time.

Day has a FAQ up on their site. As you would expect, Day promises that current customers have nothing to fear and that the products will continue to live on.

Day has some really cool stuff in both their commercial products and their open source projects (Sling, Jackrabbit). I hope the acquisition gives Day a huge injection of resources they are able to invest in the open source side of things.

Congrats to Erik Hansen, David Nuescheler, Kevin Cochrane, and the rest of the Day team!

So far, it looks like we’ll have a good mix of folks from internal IT shops, Systems Integrators, consultants, and product companies. It also looks like both proprietary and open source models will be represented.

The meetup is being modeled on others that have been successful in New York, San Francisco, and other parts of the world (see Twitter hashtag #LastThursdayCMS). The goal is to simply network with others working in this space. Hard selling and/or obnoxious recruiting will be dealt with in some sort of socially awkward manner TBD.

If the turnout is good and there is continued interest, we’ll do it again on the last Thursday of every month.

Looking forward to seeing you there.

First, let’s look at what Alfresco’s been up to lately. Over the last year or so, Alfresco has been shifting to a “we’re for developers” strategy in several ways:

• Repositioning their Web Content Management offering not as a non-technical end-user tool, but as a tool for web application developers
• Backing off of their mission to squash Microsoft SharePoint, positioning Alfresco Share instead as “good enough” collaboration. (Remember John Newton’s slide showing Microsoft as the Death Star and Alfresco as the Millenium Falcon? I think Han Solo has decided to take the fight elsewhere.)
• Making Web Scripts, Surf, and Web Studio part of the Spring Framework.
• Investing heavily in the Content Management Interoperability Services (CMIS) standard. The investment is far-reaching–Alfresco is an active participant in the OASIS specification itself, has historically been first-to-market with their CMIS implementation, and has multiple participants in CMIS-related open source projects such as Apache Chemistry.

They’ve also been making changes to the core product to make it more scalable (“Internet-scalable” is the stated goal). At a high level, they are disaggregating major Alfresco sub-systems so they can be scaled independently and in some cases removing bottlenecks present in the core infrastructure. Here are a few examples. Some of these are in progress and others are still on the roadmap:

• Migrating away from Hibernate, which Alfresco Engineers say is currently a limiting factor
• Switching from “Lucene for everything” to “Lucene for full-text and SQL for metadata search”
• Making Lucene a separate search server process (presumably clusterable)
• Making OpenOffice, which is used for document transformations, clusterable
• Hiring Tom Baeyens (JBoss jBPM founder) and starting the Activiti BPMN project (one of their goals is “cloud scalability from the ground, up”)

So for Alfresco it is all about being an internet-scalable repository that is standards-compliant and has a rich toolset that makes it easy for you to use Alfresco as the back-end of your content-centric applications. Hold that thought for a few minutes while we turn our attention to NOSQL for a moment. Then, like a great rug, I’ll tie the whole room together.

NOSQL Stores

A NOSQL (“Not Only SQL”) store is a repository that does not use a relational database for persistence. There are many different flavors (document-oriented, key-value, tabular), and a number of different implementations. I’ll refer mostly to MongoDB and CouchDB in this post, which are two examples of document-oriented stores. In general, NOSQL stores are:

• Schema-less. Need to add an “author” field to your “article”? Just add it–it’s as easy as setting a property value. The repository doesn’t care that the other articles in your repository don’t have an author field. The repository doesn’t know what an “article” is, for that matter.
• Eventually consistent instead of guaranteed consistent. At some point, all replicas in a given cluster will be fully up-to-date. If a replica can’t get up-to-date, it will remove itself from the cluster.
• Easily replicate-able. It’s very easy to instantiate new server nodes and replicate data between them and, in some cases, to horizontally partition the same database across multiple physical nodes (“sharding”).
• Extremely scalable. These repositories are built for horizontal scaling so you can add as many nodes as you need. See the previous two points.

NOSQL repositories are used in some extremely large implementations (Digg, Facebook, Twitter, Reddit, Shutterfly, Etsy, Foursquare, etc.) for a variety of purposes. But it’s important to note that you don’t have to be a Facebook or a Twitter to realize benefits from this type of back-end. And, although the examples I’ve listed are all consumer-facing, huge-volume web sites, traditional companies are already using these technologies in-house. I should also note that for some of these projects, scaling down is just as important as scaling up–the CouchDB founders talk about running Couch repositories in browsers, cell phones, or other devices.

If you don’t believe this has application inside the firewall, go back in time to the explosive growth of Lotus Notes and Lotus Domino. The Lotus Notes NSF store has similar characteristics to document-centric NOSQL repositories. In fact, Damien Katz, the founder of CouchDB, used to work for Iris Associates, the creators of Lotus Notes. One of the reasons Notes took off was that business users could create form-based applications without involving IT or DBAs. Notes servers could also replicate with each other which made data highly-available, even on networks with high latency and/or low bandwidth between server nodes.

Alfresco & NOSQL

Unlike a full ECM platform like Alfresco, NOSQL repositories are just that–repositories. Like a relational database, there are client tools, API’s, and drivers to manage the data in a NOSQL repository and perform administrative tasks, but it’s up to you to build the business application around it. Setting up a standalone NOSQL repository for a business user and telling them to start managing their content would be like sticking them in front of MySQL and doing the same. But business apps with NOSQL back-ends are being built. For ECM, projects are already underway that integrate existing platforms with these repositories (See the DrupalCon presentation, “MongoDB – Humongous Drupal“, for one example) and entirely new CMS apps have been built specifically to take advantage of NOSQL repositories.

What about Alfresco? People are using Alfresco and NOSQL repositories together already. Peter Monks, together with others, has created a couple of open source projects that extend Alfresco WCM’s deployment mechanism to use CouchDB and MongoDB as endpoints (here and here).

I recently finished up a project for a Metaversant client in which we used Alfresco DM to create, tag, secure, and route content for approval. Once approved, some custom Java actions deploy metadata to MongoDB and files to buckets on Amazon S3. The front-end presentation tier then queries MongoDB for content chunks and metadata and serves up files directly from Amazon S3 or Amazon’s CloudFront CDN as necessary.

In these examples, Alfresco is essentially being used as a front-end to the NOSQL repository. This gives you the scalability and replication features on the Content Delivery tier with workflow, check-in/check-out, an explicit content model, tagging, versioning, and other typical content management features on the Content Management tier.

But why shouldn’t the Content Management tier benefit from the scalability and replication capabilities of a NOSQL repository? And why can’t a NOSQL repository have an end-user focused user interface with integrated workflow, a form service, and other traditional DM/CMS/WCM functionality? It should, it can and they will. NOSQL-native CMS apps will be developed (some already exist). And existing CMS’s will evolve to take advantage of NOSQL back-ends in some form or fashion, similar to the Drupal-on-Mongo example cited earlier.

What does this mean for Alfresco and ECM architecture in general?

Where does that leave Alfresco? It seems their positioning as a developer-focused, “Internet-scale” repository ultimately leads to them competing directly against NOSQL repositories for certain types of applications. The challenge for Alfresco and other ECM players is whether or not they can achieve the kind of scale and replication capabilities NOSQL repositories offer today before NOSQL can catch up with a new breed of Content Management solutions built expressly for a world in which content is everywhere, user and data volumes are huge and unpredictable, and servers come and go automatically as needed to keep up with demand.

If Alfresco and the overwhelming majority of the rest of today’s CMS vendors are able to meet that challenge with their current relational-backed stores, NOSQL simply becomes an implementation choice for CMS vendors. If, however, it turns out that being backed by a NOSQL repository is a requirement for a modern, Internet-scale CMS, we may see a whole new line-up of players in the CMS space before long.

What do you think? Does the fundamental architecture prevalent in today’s CMS offerings have what it takes to manage the web content in an increasingly cloud-based world? Will we see an explosion of NOSQL-native CMS applications and, if so, will those displace today’s relational vendors or will the two live side-by-side, potentially with buyers not even knowing or caring what choice the vendor has made with regard to how the underlying data is persisted?

I’m glad to say that, although it took a while, there is now a process by which your code can find its way into the Alfresco code base (Community, and even, potentially, Enterprise). It’s called the Alfresco Community Committer Program (ACCP). The ACCP is a motley crew of volunteers from Alfresco customers and partners around the world. Although not a requirement for membership, I think most of us have developed at least one open source add-on for Alfresco. Our goal is to help community-developed code find its way into the product. Does this mean Alfresco is now as open as “true” open source community projects like Apache and Drupal? No, and honestly, I’m not sure it will ever get there. But Alfresco’s support of the ACCP process is a start. Here’s how the process works.

First step: Nomination to the ACCP Incubator

Today, developers in the community create add-ons, utilities, extensions, language packs and all kinds of software built to work with Alfresco. Some of these might make great additions to the Alfresco product. At a high-level, what the ACCP seeks to do is to act as an on-ramp or incubator for that subset of projects. We want you, real world Alfresco developers and end-users, to nominate community-developed extensions that you find useful and that you would eventually like to see as part of the Alfresco product. The ACCP then reviews these nominations and votes for their inclusion into the incubator. The project’s developers can then decide to leave their code where it is (Google Code, Sourceforge, Alfresco forge, etc.) or they may choose to migrate to the Alfresco-hosted ACCP incubator subversion repository.

Projects accepted to the incubator so far include:

• German Language Pack
• French Language Pack
• Calais Integration Semantic Auto-Tagging
• Metadata Embedders

As a side note, it’s great that there are so many community-developed add-ons for Alfresco. But the lack of a central index makes it hard to see what’s available. As a related effort, Nancy Garrity is working on something that would provide a central index, support ratings, etc.

Second step: Community code line

Once a project has been in the incubator for a while, the ACCP may recommend its inclusion as part of Alfresco Community making it much easier for Alfresco Community users to leverage these add-ons. The exact nature of how these will be made available is still being worked out. You could imagine a “community-extensions” directory under the Alfresco Community subversion root or something similar. For certain types of contributions, maybe the installer could even provide an optional “install community extensions” step. Again, although we have recently voted some projects into the ACCP incubator, none have yet to reach Community so the details of exactly how those will be incorporated into the Community code base are still being worked out.

Third step: Enterprise code line

The ACCP may then recommend Enterprise adoption. This step is subject to Alfresco Engineering approval, which may be a significant hurdle for some, but if it happens, the entire Alfresco customer base gets the benefit of Alfresco’s ongoing support of the community-developed code. Note that the Enterprise approval step is the only one where Alfresco employees have a say about how an ACCP project is handled–per our charter, Alfresco employees cannot be voting members of the committee.

How you can get involved

First, and foremost, you can nominate an open source Alfresco add-on/extension/customization project. If you want to take an active role on the committee or know someone who would be a good addition, there are spots available. So, another way to help out would be to serve on the committee or nominate someone who should. The committee meets regularly to review and vote on project and committee member nominations. All you have to do is get in touch with me or one of the other regular members of the committee. You’ll find the list on the Alfresco Community Contributor Program wiki page.

We’ll be doing a webinar on July 27th to talk about this more and answer questions. Check out the Alfresco events page to register.

Metaversant is up-and-running and I’m as busy as can be. I finally got a web site up, a logo designed, and business cards aren’t far behind. I’ve even got people to give them to which is an important pre-requisite to actually having business cards.

I’m currently billing on an Alfresco Share customization project. I can’t tell you who or exactly what but the pattern will be familiar: A company needs to manage digital assets. Some come from internal sources, some come from external sources, and all need metadata and security applied. The front-end communicates with the Alfresco repository via RESTful Web Script calls while back-office content providers and application administrators use Alfresco Share (customized here and there) to upload assets, set metadata, and manage the business process. It’s a pretty classic pattern and other than extraordinarily tight timeline pressure, it’s going well.

Beyond technical execution I’ve also conducted some Alfresco training for a pharma client in New England. It was just a quick engagement but it was fun to help a team that had been doing some playing with Alfresco on their own discover the capabilities of the platform and how they could be applied to their business problems. I also love to see the expression on people’s faces when it hits them: They don’t need Documentum for all things DM any more.

I had a great trip to New York City for the Alfresco Community Meet-up. I don’t know what the official ratio was but the customers seemed to heavily outnumber the partners as this particular meet-up which is good for everyone, I think. I caught up with a lot of old friends and met some new ones. I was particularly excited to come across someone who had some plans to leverage cmislib, my client-side CMIS API for Python, a project I’ve sorely neglected this Spring with all of the startup stuff going on. All of this Java code I’ve been writing has me missing Python–I will find time for cmislib soon.

Being fully billable while still having to find new business and take care of everything else about the business is tough, as I knew it would be. I’m loving every minute of it though. One thing I didn’t expect is the helpfulness of friends, former colleagues, and even strangers who have started their own businesses. The entrepreneur community is not unlike the open source community. Everyone loves to talk shop and trade tips and advice. It’s really cool.

My exercise regimen (a generous description) has suffered and it looks like my blogging velocity is on a similar trend. I feel like I’m getting into some regular rhythms though so maybe I can get things back in balance shortly. I’ve got all kinds of things that I need to write about: Alfresco 3.3 Enterprise is out, Alfresco hired the jBPM guys (I totally called it!), and I don’t think I’ve written anything at all about the Alfresco Community Committer Program. It’s going to be a busy Summer.

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.

Quick Review of Data Lists in Alfresco Share

First, take a look at this screencast. It shows the new Data List feature in action as well as the high-level steps needed to create your own custom Data Lists.

As you can see, Data Lists let you keep track of team information that lends itself to being managed by classic web form interactions and displayed in sortable columns. You can probably think of a lot of examples of things your team needs to track that don’t make sense in a blog or a document library or maybe need a little more structure than the wiki. The screencast showed To Do’s and Issues but it could really be anything.

In the Community 3.3 releases, Alfresco Share includes To Do Lists. It sounds like more Data List examples are coming in the 3.3g release. But if you want to add your own custom data list type, it’s really easy, especially if you’re familiar with Alfresco content models (tutorial). However, right now, this still requires XML editing. SharePoint allows lists to be defined on-the-fly, so while Alfresco’s roadmap does have this as something to address in the future, right now this is still a gap between the two products.

If you are interested in just the end-user functionality of Data Lists in Alfresco Share, this is where you should bail. If you want details on what’s going on behind the scenes, keep reading…

How Data Lists are Implemented

Data Lists are persisted as nodes in the repository. One node represents the list itself–it contains child nodes for each item in the list. The data values for each list item are stored as metadata on the node–sometimes we call these “content-less objects” because there is no file content associated with them. The nodes live in the DM repository just like data from the other tools in your Share site.

If you want to see this for yourself, go into the Explorer Client. In the Sites folder, there is a folder for Share site and within that, a folder for each site tool. Data List nodes reside in the one called dataLists. In the back of your mind you should be thinking that this means items in a Data List can trigger rules and be routed through workflows just like any other node. In fact, any API call that can work with a node can work with an entry in a Data List, including CMIS. (Shameless plug: “Heck, you could even create Data Lists with Python using cmislib!”)

You know from working with data models that each Alfresco data model has an XML file that describes it. If you go look at the out-of-the-box model directory you’ll see a new content model XML file called datalistModel.xml. If you take a look at that file, you’ll see that the node that represents the container of list items is an instance of dl:dataList which inherits from cm:folder.

The nodes that represent each item on the data list are instances of specific data list types. So, for example, the out-of-the-box To Do List has items that are of type dl:todoList. In my Issues example, Issue items are instances of scidl:issuesList. All data list item types must inherit from dl:dataListItem. For one thing, that’s how the Share user interface knows what to offer as an available data list type.

The form that’s displayed when you create and edit new Data List items is configured through the Alfresco Form Service. In my example I didn’t do anything fancy with the form, but you’ve got the full power of the new Alfresco Form Service behind you so you’re not limited to simply listing one field after another.

So, creating your own custom Data List types involves two steps:

1. Define and deploy a custom content model for your new Data List type, making sure it inherits from dl:dataListItem.
2. Configure the Alfresco Form Service in the Alfresco Share application to display the metadata from the custom Data List in the create and edit forms as well as in the browse grid.

In my example, I used an AMP to deploy the content model to the repository tier (my Alfresco WAR) and a JAR to deploy the form service configuration to the presentation tier (the Share WAR).

If you want to try this example in your own environment, you can download the Eclipse project here. It includes an Ant build file, the content model, and the form configuration. Note that I deployed the Forms Development Kit to both the Alfresco and Share WARs prior to deploying my Data List form configuration. The example assumes you’ve done the same. If you don’t want to fool with the FDK, that’s cool, it’s not required for data lists. You may want to look at the Forms Development Guide for tips.

On one hand, I was sad to leave Optaros–it was a great place to work with lots of smart people and interesting clients/projects. And I had fun building the ECM practice into a significant portion of overall revenue. On the other hand, the timing felt right to make this change and I’m very excited about starting my own company. Optaros and I are on great terms and I’m sure we’ll find ways to do business together going forward.

There are a lot of to-do’s to get Metaversant fully functional as a corporation, but nothing’s more important than the success of your project. If you are looking for help in any of the following areas, we should talk:

• Customized, on-site Alfresco developer training
• Short-term tactical technical assistance
• Architectural reviews/product fit assessments
• Content Management customization & implementation leadership
• Custom content-centric application development & integration
• Domino.Doc, Vignette, Stellent, or other legacy ECM migrations

You can contact me at “jpotts” at either this domain or metaversant.com.

As usual, keep an eye out here for news on Metaversant (like a link to the yet-to-be-built web site) and other content management news and thanks for your continued support!