≡ Menu

Book Review: Practical Plone 3

With the proliferation of content management system (CMS) software, a need has arisen for good manuals. When a CMS starts out, user forums are usually the main place for help;  then someone will start a wiki, and a few people will write tutorials on their blogs. But if the user base for a CMS grows rapidly, docs quickly go out of date, and it becomes hard to figure out which parts of the docs still apply for the latest release.  That poses a risk for someone wishing to buy  a technical book (or  write  one).  Technical publishers use several methods to future-proof their books. This includes: focusing on core features unlikely to change between releases, anticipating future development, publishing smaller books that require less time to produce and group writing. Group writing (assigning different people to contribute chapters) has been a popular method because it reduces the burden on one person. As long as the assigned topics don’t overlap and are well organized, group-written technical books can be extraordinarily helpful and can be released quickly, as in the case of  Packt Publishing’s latest Plone book (Practical Plone 3).

First, a little background. Plone is a python-based CMS that has a large user base and many enterprise  features. It is deployed on many nonprofits and governmental sites and historically has been easier to secure than LAMP CMS’s like Drupal. Data is stored in an object database (ZODB)  as opposed to relational databases (although adapters have been written to connect to mysql, postgresql, etc).   Plone is based on a platform called Zope, and in fact Plone’s version 3  release in 2007 implemented many architectural changes.
Packt has published several Plone books already (including Martin Aspelli’s well-regarded 2007 book Professional Plone Development), and the latest book is bigger, covers more topics and should interest a wider audience.  

About half of the pages (and a third of the chapters) in this 565 page book contain screenshots to demonstrate functionality which can be controlled with the web interface. However, the book’s audience is not really for novice users or content creators (despite the book’s subtitle that is a "beginner’s guide"). If you wish for something like that, try  the excellent Users Guide to Plone —downloadable for free). Practical Plone 3 covers basic topics in Chapters 4-6, but it focuses on several  topics which are not easy to find the answers for. This book would be useful for the website administrator or the developer or designer trying to customize Plone for an organization or company.

First, Plone includes lots of features not enabled by default which are hidden in the administration menu (called "Plone Site Setup"). Unlike Drupal (which seems to have a massively complex control panel), Plone Site Setup looks deceptively simple, but lots of things are hidden under the hood. So you need to know where to look.   Practical Plone 3 explains how to use a lot of these features:  versioning, managing groups and roles, creating custom workflows and using the portlet manager to control what sidebars appear on the left or right of the web page.

Plone differs in many ways from LAMP CMSs both in architecture and concepts. Usually, these differences remain hidden from users. But  understanding these  differences can help you  understand why things work differently in Plone. For example, Plone uses the folder-file metaphor for content objects. They can have states and properties; they can be copied/cut/pasted into other Plone folders even though they don’t really exist as files or folders on the file system itself. Another easily overlooked feature is the extensive metadata fields that exist for content types. (it exists in a secondary horizontal tab  like this one ).

The book chooses (wisely) not to talk too much about third party Plone  products (i.e., plugins). But it does go into great detail about using PloneFormGen (an auto-generator of web forms) and cache-fu (an indispensable product for caching performance). These two sections were very well done.

The last half of the book describes  how Plone development proceeds, beginning with creating  new content types. In Chapter 16, the book covers how to use a graphical UML tool called ArchGenXML to create a new content type based on the builtin content types. Here you use Archetypes, a Plone-specific way of building content types. (Archetypes have been around since Plone 2). After you use the graphical tool to create UML, the ArchGenXML script will generate the product code for you to upload to the server’s file system.  Later, in Chapter 17, there is a good walkthrough of using Generic Setup to export configuration changes you make in the Zope Management Interface (ZMI) into an XML file on the file system.  That allows you  to replicate site configuration more easily and  keep configuration information outside of the database.   Chapter 17 also  covers the Zope 3 architecture underlying Plone and how to set up browser views in ZCML configuration files and viewlets and portlets.

Chapter 18 covers the creation of themes and css for a Plone site. This process is slightly complicated because you make your changes to a themed product which is later installed/enabled from Plone Site Setup. The book walks you through the steps of using a python script called paster to generate a series of files which make up the theme product. Editing the css for the theme is possible only if you understand how viewlets work and which files you are supposed to edit (it is not simply a styles.css file).

The last two chapters cover caching and performance tuning. Overall, well done.

In general, this is an excellent guide and it covers a lot of ground thoroughly. Unlike the Drupal series of books by Packt (which struck me as flimsy–they have 12 separate books!), this book  combines  all the important aspects of Plone 3 into  a single book.  Everything in the book struck me as important–none of the material seemed like padding. The usage information in the first section was very well done (although it probably needed better coverage of Kupu, the rich text editor).  The section on workflows was great, and the explanation about Zope 3 views seemed well done, but the look-and-feel chapter looked imposing. If editing a CSS class means having to edit a theme product and re-add it, that might discourage doing too many tweaks (especially on a live site!). It would have been nice to have an appendix summarizing the configuration files, location of important objects in the ZMI and CSS classes.   I did not see any chapter  about uploading images or multimedia files on the file system; that seemed to be outside of the book’s scope.   I am not a developer (I just play one on TV), but there seemed enough meat in the advanced sections to address many contexts.

Finally, it’s worth pointing out that the plone.org site has a well-organized documentation section. The book may lack a good section on kupu, but plone.org has  several help topics about Kupu.  (In fact, many of the book’s contributors also produce documentation for the Plone.org site). One doesn’t read this kind of book for narrative; nonetheless,  most of it was easy to read and easy on the eyes.  Except for chapters 17 and 18 (which were a little deep), the rest of the book got straight to the point quickly.

In summary: this book is a substantial guide which covers a lot of intermediate and advanced topics. Very well written and organized (with lots of illustrations), but the section on themes was hairy and even a little confusing


Robert Nagle is a technical writer and fiction writer who lives in Houston.  He blogs about culture and technology on his idiotprogrammer weblog.

{ 1 comment… add one }
  • Jon Stahl 5/13/2009, 12:54 am

    Thanks for the thoughtful review, Robert!

    You’re right — the main reason we didn’t address Kupu in depth is because it is already well documented online and in the free User’s Guide.

    You can of course edit CSS stylesheets through the ZMI, which is what many people do when tweaking “live” sites… it’s a fine practice, so long as you eventually roll the changes back to your filesystem product and SVN.

Leave a Comment