Tag: book

Deal of the Day: 50%-off CMIS & Apache Chemistry in Action

The book I mueller_cover150co-authored with Florian Mueller (SAP) and Jay Brown (IBM), CMIS and Apache Chemistry in Action, is 50% off today (January 30). Use code dotd013014au when you checkout.

If you are doing anything with CMIS, whether that is with Alfresco or some other CMIS-compliant Enterprise Content Management server, like Nuxeo, SharePoint, FileNet, or Documentum, you should really take a look at this book. It provides Java, Python, PHP, and .NET examples including a working web application.

Happy 5th Birthday, Alfresco Developer Guide!

Birthday Cake by Will ClaytonIt is hard to believe that the Alfresco Developer Guide was published five years ago this month (really, the tail end of October). My goal at the time was to help flatten the learning curve around the Alfresco platform and encourage people still using legacy ECM systems to make the leap. Based on the number of people who come up to me at meetups, conferences, and other events to tell me how much the book helped their projects, their teams, and even their careers, I’d say that goal was met and that makes me very happy.

The product and the company have definitely evolved a lot since 2008. The chapter on WCM is no longer relevant. The section on Single Sign-On is out-of-date. The book was written before Alfresco Share existed. And, at the time, jBPM was the only workflow engine in the product and Solr was not yet on the scene, nor was mobile. Both JCR and the native Web Services APIs have given way to CMIS as the preferred API. And Maven and AMPs are the recommended way to manage dependencies, run builds, and package extensions.

But the fundamentals of content modeling haven’t changed. Rules, actions, and behaviors are still great ways to automate content processing. Web Scripts are vital to any developer’s understanding of Alfresco, including those doing Share customizations. And, though the preferred workflow engine is Activiti rather than jBPM, the basics of how to design and deploy content-centric business processes in Alfresco haven’t changed that much.

So where do we go from here? The book was originally based on a set of tutorials I published here on ecmarchitect. Last year I created second editions of many of the tutorials to catch them up with major advancements in the platform. For example, the custom content types tutorial now includes Share configuration and CMIS. The custom actions tutorial now includes how to write Share UI actions. And the workflow tutorial now assumes Activiti and Alfresco Share rather than jBPM and Alfresco Explorer.

The source code that accompanied the book lives in Google Code, but I recently moved the source code that accompanies the tutorials to GitHub. I’m busy refactoring the tutorial source code to use Maven and AMPs. I’ve also started moving the actual tutorial text to markdown and am checking it in to GitHub so that the community can help me revise it and keep it up-to-date.

I learned a lot writing that first book. One of the lessons is to always work with co-authors. That made a big difference on CMIS and Apache Chemistry in Action. I hope that book helps as many people as the Alfresco Developer Guide did and I look forward to reflecting back on how CMIS has changed on that book’s fifth birthday in 2018.

Book Review: Alfresco 3 Records Management by Dick Weisinger

Packt Publishing sent me a copy of Dick Weisinger’s new book, Alfresco 3 Records Management, to read and review. Now, before I tell you what I thought of the book I have to say that I don’t perceive a huge demand for Alfresco’s Records Management offering and I haven’t heard them talk about it much lately. I don’t know if my perception matches reality and, if it does, why we don’t hear about it more often. An open source, DoD-certified, freely-available Records Management product definitely sounds unique and compelling. It could be such a focused niche that there’s a lot of activity around it that I’m simply not aware of.

Still, I was curious to learn more about the topic and Alfresco’s offering, so I gave it a go.

Let me start by saying that Dick does a fabulous job of defining a topic area and a target audience and sticking to that. The book is 457 pages without the online appendices but it feels concise. I think that’s because it is well organized, clearly written, and flows logically and seamlessly from one chapter to the next.

The book is written for both Records Managers and Software Developers. You’d think that having such disparate audiences would be a problem, but Dick handles it very well. Every chapter starts out with an end-user description of the Records Management functionality and then when everything’s been covered, shifts to a “How Does it Work?” section that dives into the technical details behind the functionality covered in the first half. Too often, books written for both technical and non-technical audiences munge their material together in such a way that is frustrating to both audiences. In this case, the content is separated cleanly so it works very well. If you are a Records Manager, and you have no desire to peek under the hood, you can read this book and easily skip the “How Does it Work?” section in each chapter without being confused or distracted.

But here’s the other thing that’s going on, which I thought was really cool. Even though the book is about Records Management, Dick’s managed to write a Share customization primer. As I was reading, I was thinking an alternate title for the book could be, “Learning Share Development by Deconstructing the Alfresco Records Management Application” (if you’re not into the whole brevity thing).

Alfresco’s Records Management add-on is actually just a set of repository tier and Share tier customizations. So, if you learn how the Records Management app is built, you learn how to build other Share-based solutions. In the book, each chapter’s “How Does it Work?” section covers a different example of Share functionality and how it works behind the scenes. So, someone who’s interested in learning about Share customizations can read this book from that perspective, and essentially use Records Management as one big sample application.

For example, in Chapter 5 the Records Manager learns how to set up a file plan. In the same chapter, a developer learns how the YUI data table that renders the file plan actually works. In Chapter 9 the Records Manager learns about holds/freezes, retention, and reviews while the developer learns how to configure scheduled jobs and how Share UI actions work. Every chapter works this way–I’m just picking out a couple of examples.

Don’t get me wrong. I’m not saying that you can go from zero to Badass Share Developer with this book alone. That’s not going to happen. But as Dick says in the summary of the last chapter, it’s a good start. The technical sections give you a pointer to the pieces that make up a particular area of functionality. That’s useful if you want to change how Records Management works but you can also use it as an example for adding similar functionality to your own Share-based app.

One thing that frustrates developers trying to customize Share (and Records Management) is the question, “Given what I’m looking at in the browser, where does the code reside that makes it work?”. The book shows the technical reader how to go from Share page to template to component to Spring Surf web script which is something you do over and over when you are first learning how Share is put together. Being pointed in the right direction and being shown the general pattern that the Share developers followed is really valuable.

So, if you’re thinking about implementing Records Management, and you need to know whether or not Alfresco’s offering will fit the bill, this would be a great book for you to read during your evaluation or after the selection has been made and you need to learn how to install and configure the product. If you are the technical person on the implementation team, the book will give you the end-user context as well as a peek under the hood. If you need to customize the product and you’ve never done Share customization work before, you’ll learn how Spring Surf works and, more importantly, given a piece of functionality, you’ll know where to look when you need to change it.

Well done, Dick!

Book Review: Alfresco 3 Business Solutions by Martin Bergljung

[UPDATED: To remove my comment about the absence of workflow config in Share, which Martin does cover. Sorry about that, Martin]

Packt Publishing sent me a copy of Martin Bergljung’s new book, Alfresco 3 Business Solutions. I just finished reading it, so I thought I’d write a quick review.

Overall, I think it is a good book with a lot of useful information across a variety of topics. The preface says the book is for “systems administrators and business owners”. Inclusion of “business owners” is a stretch–they’d have to be pretty technical to get something out of this book. I think the intent of including “business” in the title and the target audience is to set up the book as more of a solution-oriented look at Alfresco and less of an exhaustive technical how-to.

Bergljung attempts to organize the book around “business solution” focused chapters. For example, if your main concern is letting your users access the repository through file protocols, then Chapter 5, File System Access Solutions, is for you. If you are doing a content migration to Alfresco, Chapter 8, Document Migration Solutions outlines the different approach available for doing that. I think this is a good approach for the stated audience and most of the chapters fit the approach.

The book starts out with an overview of the Alfresco platform and various repository concepts. Although there are places that risk going into too much detail too early, that first chapter would be a good read for anyone new to Alfresco. The chapters on authentication and synchronization (Chapter 4) and CIFS/WebDAV (Chapter 5) are very thorough and provide some of the best coverage of those topics I’ve seen in any of the Alfresco books. The vigor with which Bergljung attacked those topics makes me think those areas are a particular passion for him. If you are strict about the target audience, Chapters 4 & 5 are definitely the strongest in the book.

However, at various points, the book strays from its intended audience and starts to go into developer topics. Don’t get me wrong, that’s the most interesting stuff to me, but I think it is potentially confusing (or, at best, superfluous) to system administrators. For example, the end of Chapter 1 covers the underlying database schema. Maybe it is a good idea to discuss what the tables are and how they are used so that a DBA gets a feel for the schema and can tune the database appropriately. But Alfresco’s schema is not public and shouldn’t be accessed directly unless you know what you’re doing and if you are willing to sign up for the inevitable maintenance down the road when the schema changes without warning. Bergljung gives a soft warning to this effect at the start of the section but the negative effects could have been emphasized more.

There are a few other developer-centric concepts in the book that I just simply don’t agree with. The first is about AMPs. In a couple of places, Bergljung implies that the Java Foundation API and AMPs are somehow dependent on each other. The statement, “The Foundation API is only used when deploying extensions as an AMP,” is just not true. Later, another statement compounds the problem by saying, “AMP extensions require Java instead of JavaScript”, which, again is not accurate. For some reason, the author is trying to link an API (Java, JavaScript) with a deployment approach (AMPs) which are not related or dependent on each other at all.

Another piece I don’t agree with is about $TOMCAT_SHARED. To be fair, I’ve seen this in other places and have heard certain Alfresco Engineers encouraging the use of $TOMCAT_SHARED for things I think belong in the web app instead. Regardless of where it comes from, I think it’s really bad advice to tell people to use $TOMCAT_SHARED for anything other than alfresco-global.properties and server- or environment-specific settings. Proponents of $TOMCAT_SHARED will say they like deploying their customizations there for two reasons. First, when Alfresco and Share are deployed in the same Tomcat instance, you can deploy your extensions as one package and both web apps will use it. Second, your extensions go into an extension directory external to the Alfresco WAR, which keep them well away from Alfresco’s code. In my option, both of these are actually reasons NOT to use $TOMCAT_SHARED. Why? As to the Alfresco/Share sharing bullet point, why unnecessarily couple those two web apps together? The Alfresco and Share WAR are built to run on completely separate nodes which is helpful. We shouldn’t ruin that by making them both rely on the same shared directory.

As for the “keep your extensions away from Alfresco’s” reason, that’s what the extension directory is for. I can keep my customizations separate and still have them reside in Alfresco’s WAR. In fact, most clients I’ve dealt with prefer that because they have IT Operations teams that only want to deal with self-contained WARs. Being a “special case” is not how you win the hearts and minds of your infrastructure team.

Now, with these picked nits out of the way, I should say that there are some developer-oriented topics that were very good. Bergljung has some good Java Foundation API and JavaScript API examples in Chapter 2 covering Node Service and other commonly-used services. And I like the section in Chapter 3 that talks about setting up Apache Hudson for continuous integration. Chapters 9 through 11 provide good coverage of Advanced Workflows, from designing workflows with swimlane diagrams to a lengthy example showing super states, sub-processes, and custom workflow management dashlets.

In keeping with the “solutions” approach, I think I would have combined the portlet chapter and the mobile app/Grails chapter into a single “integration solutions” chapter and talked less about the specific implementation details and more about the touch points: options for integration (Web Services, CMIS, custom web scripts), single sign-on approaches, what’s available out-of-the-box, caveats, etc. Most of this is covered one way or another between the two chapters. It just seems like a common thing people think through is “What’s the best approach for doing X on top of Alfresco” where X is a portal like Liferay, a community platform like Drupal, a mobile app, and so on.

So, if you’re a “business owner” and by that you mean “non-technical end-user”, you’d probably be better off with Munwar’s book, which is definitely end-user focused. If you are a “system administrator” or someone who needs to know the capabilities of Alfresco and how to integrate Alfresco with various touch points (LDAP, Active Directory, portals), it’s definitely worth a read, particularly if you need to deal with external authentication sources or you are responsible for getting CIFS working. Developers will benefit from the API examples and the chapters on Alfresco’s embedded jBPM engine.

Congrats to Martin and Packt. It’s good to see another title (I think we’re up to 8 or 9 now) added to the Alfresco bookshelf.

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.

Book review: Alfresco 3 Content Management Implementation

Packt recently sent me a copy of Munwar Shariff’s updated book, Alfresco 3 Content Management Implementation. The book is a comprehensive guide to Alfresco from an end-user or power user perspective.

How comprehensive? This edition offers 239 new pages (including the index) over the original. That’s a lot of net new content. The first seven chapters are roughly the same as the first edition, covering fundamentals, installation, security, basic library services, rules, and the content model. The Collaboration and Syndication coverage has morphed into a chapter on Share & SharePoint which is very timely as there is a lot of activity around that area of the product right now.

The organization of the book feels improved over the first edition. It now follows a very logical progression through the entire platform. There are still places where the information feels superfluous (the discussion of ActiveDirectory versus Novell eDirectory, for example) or aimed at a different audience (Chapter 9’s coverage of integration with other systems) but overall I think Shariff and his team have done a great job of covering an expansive platform and its many use cases.

If you are evaluating Alfresco, just getting started with the platform, or you are looking for the missing manual for end-users and power users, you should take a look.

Disclosure: Packt provided me a copy of this book free of charge. Also, Munwar and his team of authors work for Cignex, a services firm that, from time-to-time, competes for business against my company, Optaros.

Packt Author of the Year Award

I mentioned it on Twitter yesterday but I definitely wanted to spend more than 140 characters saying thanks. If you missed the tweet, what I’m talking about is that Packt announced that I won the Author of the Year Award for the Alfresco Developer Guide.

Earlier this year they had a nomination process which resulted in readers choosing me as a finalist. Getting that far was really cool and I definitely want to say thanks to the readers of the book and the blog for making that happen.

The next step was a round of judging. This took a while and I can’t imagine the process whereby you get a panel of judges, with different backgrounds and full-time jobs (I assume) to look at six technical books that cover a wide range of topics (Alfresco, Drupal, Ext JS, JavaScript, and SOA) and subsequently make sense of the feedback. Definitely a big thanks to Packt and the panel of judges who worked hard to make this happen.

The book was certainly a team effort. I had a great team of technical reviewers, and they were instrumental. I think it’s also important to recognize my firm, Optaros, because the project couldn’t have happened without their support and encouragement. The entire Alfresco team also got behind it in one way or another and that was important to the success as well.

Alright, enough said. I’ll quit before I start working my way down the family tree. Maybe Twitter’s length restriction really is the best thing for an acceptance speech. Thanks, again, to everyone involved!

Save 15% on Alfresco Developer Guide

Forgive this temporary transgression into a blatant sales pitch, but I’m trying to save you some money. Packt Publishing is offering ECM Architect readers 15% off my book, the Alfresco Developer Guide. To take advantage of the discount:

  1. Visit the Alfresco Developer Guide Book Page
  2. Click the “ADD TO CART” button to add the book to your shopping cart
  3. Enter AlfrescoDG-3117 in the “Promotional Code” field and click the “Update Button”. The discounted price should now be reflected in your order.

After your book arrives, if you read it and decide it was the best Packt book published in 2008, you should take a minute to vote for the Alfresco Developer Guide in Packt’s Author of the Year awards. Voting ends May 25.