Time for a new review of a Plone book! This time it’s Plone 3 Multimedia, by Tom Gross, and published by, guess who… Packt Publishing! One would say that Packt has a really good marketing team. :P

The mistake in the title is here strikes once again, since most of the book, if not it all, will apply also for Plone 4, but Packt continues following this policy.

First think I thought was… do we really need a whole book about multimedia in Plone? The answer is, well, there is enough material, enough multimedia-related products for Plone out there to write a book about the topic if you want to.

One thing I don’t understand is what the target audience is supposed to be. The “Who this book is for” section claims that (please Packt don’t sue me for copyright-related issues ;):

This book is for Plone integrators who want to extend the core of Plone with multimedia features. It gives no introduction to Plone and readers should know how to set up a Plone site using a buildout. The book can be read and understood well even if the reader is not a Python developer, though some examples have Python code included.

The book starts giving definitions of what a CMS or what multimedia is and the different types of multimedia elements we can stumble upon, so you think it’s going to be soft, but it soon dives into using multimedia in Zope Page Templates and Python code, and later uses some more advanced concepts (e.g. automated testing, traversers, marking interfaces, zope events…) without (IMO) proper introduction.

Is not that I can’t accept the reader is required to have some former Plone knowledge — what I don’t understand is the mixture of really-newbies with more advanced coding material.

I would have appreciated a kind of requirements story to give more coherence to the content as a whole, something like what happens in the Plone 3 Products Development Cookbook or Proffessional Plone Development: a fictitious client that presents some requirements for a to-be-developed Plone site.

Plone 3 Multimedia doesn’t follow this pattern, and the result is a different structure, a reference presenting and briefly explaining different products to add multimedia features to your site, like the whole Plone 4 Artists (p4a) suite, plonetruegallery, Slideshowfolder, collective.flowplayer, Plumi, Vice, collective.uploadify or Red5, among others.

The two last chapters deal with what I think are vital topics when dealing with multimedia: storage and caching. In the storage one, I miss some more guidance about which storage system choose in every situation and why, instead of just a list of different available products with storage-related features.

Finally, I don’t think the appendices, covering multimedia and syndication formats, licenses and links for getting more help, are worth it. We already have Wikipedia, Google searches and all, so if one wants to read about, say, Ogg Vorbis, one ends here or here, with a lot more info that what one can find in the corresponding appendix of the book. All these pages could have better been employed in explaining more deeply the more advanced technical concepts, for example.

To sum up, I find this book good for “advanced” integrators or developers who are looking for an overview of the different available multimedia products for Plone. For the rest, I’ve not doubt you can learn something from it, but perhaps others fit your profile better.

The list of reviewers, comprising Martin Aspeli, Alec Mitchell and Emanuel Sartor, being as they are core and very active developers, automatically made me think this was going to be an accurate and up-to-date book.

This is the second book in the market about modern development with Plone, after Martin Aspeli’s Proffessional Plone Development. And after having skimmed through it (if you try to proof-read this kind of books from top to bottom your brain can explode), I can say that it’s probably going to become a classic invaluable reference as PPD already is.

Plone 3 Products Development Cookbook spans over 350 pages full of useful tips, set-up instructions and step-by-step coding approaches to solve specific use-cases (that’s why it’s called “cookbook”). Even if the book title says Plone 3, I think it’s just a Packt policy – one can be sure that most of the contents (if not all them) will be valid for Plone 4 too, and the authors even included some special instructions for Plone 4.

The book show-cases the development of an hypothetical digital newspaper with Plone, covering the whole process: From installing Python and Plone in Linux or Windows (Mac OSX specifics aren”t covered in this book) to preparing the production environment, passing through the installation of useful development tools like ipdb, DocFinderTab or plone.reload, creating content-types using ArchGenXML, paster-aided plain Archetypes or Dexterity, internationalizing and localizing the product, building XML-RPC interaction with other systems, and more (see the full table of contents). All the features coded include automated tests, what is a Very Good Practice and will help devs to be less afraid of writing tests.

The book is organized in a recipe-list fashion, in chapters, every recipe including “getting ready”, “how to do it”, “how it works” and “there is more” sections. Sometimes the separation of concerns between these sections is not very clear, but one can expect a series of short steps in “how to do it”, to use as reference, and some brief explanation in “how it works”.

In my opinion, this is not a book for beginners. Even if there are some explanations in the “how it works” section of each recipe, they are almost always quite brief, and can certainly make you have to re-read and Google for more documentation often, if you really want to understand how the Zope Component Architecture, ZPT, skin layers, z3c.forms, etc. work. I see it more as a reference book for more advanced developers, who can also discover in this book some tricks and approaches they didn’t know before – I certainly did!

Summing up, this is a really useful reference for folks with previous developing experience in Plone. My sincere congratulations to the authors for their hard work to make this happen – I’m sure it will hit the shelves of every active Plone developer!

For those of you not familiarized with Plone nor web development nor computers: I want to press a lot of buttons to make the pattern of lights shown in a metal rectangle change however I want. (credits to xkcd #722 ;)

For the rest of you, here goes my Google Summer of Code 2010 student proposal!

Core tiles development

Deco is a revolutionary page composition system heavily based on semantic HTML and middleware software (either WSGI or using a post-publication hook), which could probably be shipped by default with Plone 5. The underlying Deco architecture, based on the concepts of panels and tiles, needs a set of core tiles (image, video, navigation tree, content-type field) to be inserted in the page.

What are you studying, and where?

I’m a Physics student from the Universidad Complutense de Madrid, Spain. I’m studying now in Stockholm (Kungligla Tekniska Högskolan) as an Erasmus student, and will study in Barcelona next year within another exchange programme (Séneca).

What is the most interesting programming project you’ve undertaken while at university?

I’ve coded a C++ app to solve the minesweeper game using different chained strategies.

Have you ever contributed to an open source project? If so, give details.

(Remember, filing bug reports and writing documentation are every bit as much contributions as writing code)

I’ve contributed to:

- Flock: Bug reports and translations to Spanish, as well as trying to lead the l10n team for a while.

- Mozilla: Providing help in the Mozilla Hispano (community website) forums, as well as writing some end-user documentation and a localization QA application in Django.

- Alqua: Wrote part of the code to use LaTeX templates written in the Cheetah template language to generate quality documents.

- Plone: Contributed and managed developer documentation. Leaded efforts to write documentation for the upcoming Plone versions. Reported a bunch of bugs, and fixed anohter (coding).

Have you used Plone before? What for?

Yes, for the Alqua website, in my first job (Zassh website), working with the Plone community and in my current job in Webworks.

Have you spoken to anyone in the Plone community about your project? Who?

Yes, Martin Aspeli, Geir Baekholt, Matthew Wilkes, Alexander Limi, David Glick, Rob Gietema and I guess some others I don’t remember right now.

What is your project idea?

This is the most important bit, so be as detailed as you can.

Deco is a new and exciting new way of composing, and I’d say that even theming pages and a website. It allows the user to create flexible grid-based layouts for the contents directly through the web without the limits of portlets and viewlets positioning and unifying these two concepts through the idea of “tile”.

Some sample tiles have been developed as a proof of concept (example.deco), but we need to develop a set of standard core tiles, including the so-called “application” ones like Text, Navigation, Image, Video, Calendar, Login Box, Search Box, Map, RSS Feed or Comments, and the field-type one, which can represent fields like Title, Description or Date. These last one would be probably integrated with Dexterity.

I want to create all these, and I think that we will find and solve a lot of issues underlying the current architectural Deco code in the way. The collective.tinymcetiles product, already usable, will allow us to insert tiles in Rich Fields and therefore test them.

At the same time, most of the infrastructure and API for creating, storing and displaying tiles is already completed (plone.tiles and plone.app.tiles), as well as the system to merge and render panel layouts (plone.app.blocks), but we still lack a system to store and manage site and page-wide layouts. I want to work also on the design and implementation of this system, with the help of my mentor.

Finally, and keeping in mind the radical change of concept Deco involves, I’d like to write quite a lot high and low-level documentation about how the whole system works, ensuring a smooth transition curve for people already used to the old way as long as newcomers.

Please complete the following sentences about how you see the state of the project at different points in the timeline:

At the start of the official coding period (i.e. a month after the accepted projects are announced) my project will be …just about to start after having read the documentation about the different packages involved and played with them, creating some test tiles and some test Dexterity content-types, to understand better how they work.

3 weeks into the official coding period my project will be …having coded an alpha version of most of the application tiles: Image, Video, File, etc. These tiles can work with Archetypes content types and collective.tinymcetiles.

Half-way through the coding period my project will be …having coded an alpha version of a sample field tile. These tiles would extract the data from a Dexterity content-type. example.deco already implements a proof-of-concept for a field tile, but this implementation needs to be rethinked according to M. Aspeli. Field tiles won’t probably work well with with collective.tinymcetiles, but Rob Gietema (from 4Digital) is already working on the plone.app.deco package to support this.

3 weeks from the end of the coding period my project will be …having polished the previous tiles and started working on a Dexterity “Page” content-type to be able to insert field and app tiles in it without collective.tinymcetiles.

At the end of the coding period my project will be …finished working on the Page type and the previous tiles.

3 months after summer of code finishes my project will be …hopefully continued to fix bugs and improve it! It will need to if we want it to make into Plone 5.

Do you have any other commitments during the summer of code period (i.e. between June and August)?

I plan to travel for holidays for at least a week. I also have to move from Madrid to Barcelona, so I’ll need to look for an apartment there and probably will be busy for a week or so till everything settles down again in my life. :)

I’ll also attend the Plone Symposium East 2010 at the end of May.

I also plan to attend the Plone Conference 2010 this Autumn.

Both the author, Erik Rose, and the technical reviewers are well known and respected in the community. I’ve chatted more than once with two of the reviewers, Steve McMahon and Denys Mishunov, and I know they’re quite skillful and competent, so you can expect the book to be correct and well-written.

I must admit that, at first, I was a bit annoyed with the step-by-step recipe-style of the book. Being a Physics student, I’m used to read texts where the main points of the theory are explained, but the step-by-step procedure is often left as an exercise to the reader. Having to follow closely a list of steps makes me feel like a script-kiddie: somebody who executes a series of steps without actually understanding what is she/he really doing.

However, Erik has taken care of providing a lot of contextual explanation about the steps, with comments about the different options you have and why would you prefer to choose one or another. Moreover, the just-follow-these-steps approach is not so heavily used after the two first chapters.

Although the title of the book suggests that people in the educational context are its only target public, you can learn a lot from its suggested approaches even if you aren’t into education. Being very, very practical, it covers a freaking impressive list of tasks/features: making academic courses available on-line, a directory of personnel, setting-up a blog and a forum, publishing audio and video, creating forms easily, theming a site and managing a production system.

I wouldn’t have covered the theming and the sysadmin stuff, since it’s quite technical and there are already (or are coming) good book references on these subjects, including the Plone 3 Theming by Veda Williamson, Practical Plone 3, or the upcoming Plone 3.3 Site Administration by the popular Alex Clark. By the way, Alex, please tell Packt that this title is not attractive at all marketingly-speaking — people will think that the book only applies to 3.3!

Unlike other books, which are quite bare-Plone centered, a lot of interesting add-on products are documented, more or less extensively: FacultyStaffDirectory (of which Erik is an active contributor and therefore even provides tips about future development!), p4a.Calendar, Scrawl, QuillsEnabled, PloneBoard, collective.flowplayer, p4a.video, p4a.audio, PloneFormGen, z3c.jbot and CacheFu, among others.

Erik doesn’t simply provide general technical manager advice, but also tells you about good practices for content editors based on his previous experience and known pitfalls. What is even more impressive, he sometimes points you to some tickets in Trac about open issues! While this would be more suitable for on-line documentation, it reflects the active involvement and time Erik has spent on investigating what he’s writing about. Good work, Erik!

The book is full of evangelism, specially in the first chapter, where it comes in loads. While it shows that Erik (and the reviewers?) is really passionate about Plone, I guess that who bought this book is looking for info about how to use the product, not marketing stuff, and perhaps these pages could have seen better use with some images, more extensive explanation of a certain feature, or just removed and the price of the book lowered. But this is only the opinion of someone who’s already convinced of the coolness of Plone. Erik also takes the opportunity to expose his political view about the issues with buildout, installation and packaging.

The writing style is clear and always fun. Sentences like “Who can resist puppies? They are heart-meltingly cute and loads of fun, but it’s easy to forget, when their wet little noses are in your face, that they come with responsibility. Likewise, add-ons are free to install and use, but they also bring hidden costs.” make you smile and remind you that some people in the Plone community have a good sense of humour and are crazy enough to publish this kind of stuff in a technical book. :)

Kudos to Erik — while I was certainly biased about reading a book for non-developers and just for Education, you managed to make me learn new stuff and enjoy doing so!

I’d like to thank Packt Publishing for providing me a free review copy of the e-book for my reading pleasure. The 2nd chapter, Calendaring, is available from their site free of charge, in the case you want to take a peek before considering to get the book.

• I had free time.
• I love coding for fun.
• I wanted to experience myself how easy/hard can be to updating a Plone 3 product to work in Plone 4.

The changelog will tell you about every change I performed, but a summary of the most important stuff is:

• The attribute __implements__ of a class cannot be used anymore. Use zope.interface implements and implementsOnly instead.
• Use mailhost.send instead of mailhost.secureSend. Learn how to upgrade your product accordingly (thanks alecm!).
• Manually define all needed variables which were formerly globally defined in the famous main_template. This was the most time-consuming step, because I had to fix them one-by-one following a try-error approach. Thanks god PHC has automatic tests, which helped a lot there.
  Perhaps we could come up with a handy find-grep expression to be run in the root of your add-on package to identify all templates where you’re using global expressions (no longer available). find-grep hackers are welcome to comment this post. ;)

Thanks god, there’s a buildout recipe (we should create a Linux distro based on buildout someday, alecm ;) to build Python from source in an isolated environment. Steps:

1. svn co https://svn.plone.org/svn/collective/buildout/python/ buildout.python
2. cd buildout.python; python bootstrap.py
3. Edit buildout.cfg to fit your needs. You might want to comment out the references to the Python versions you don’t want to install.
4. bin/buildout
5. cd to-another-directory; paster create -t plone3_buildout plone4.
6. Enter “4.0a1″ (without quotes) when asked about “Which Plone version to install”. Make sure you have the last version of ZopeSkel (2.14.1 while I’m writing this – easy_install -U ZopeSkel) or the generated buildout.cfg won’t be valid for Plone 4 otherwise. Thanks to MatthewWilkes for the pointer and of course for the ZopeSkel release. :)
7. path-to-buildout.python/python-2.6/bin/python bootstrap.py
8. bin/buildout. If you get tons of lines in your console output about fetching distribute, see this post by Reinout van Rees.
9. You’ll need to install PIL to run Plone, so do either:
   1. python-2.6/bin/easy_install-2.6 http://dist.repoze.org/PIL-1.1.6.tar.gz, or
   2. Add PIL or PILwoTk to any of the eggs sections of your Plone 4 buildout and re-run bin/buildout.

If you stumble upon an error message similar to:

Downloading http://dist.repoze.org/PIL-1.1.6.tar.gz
Processing PIL-1.1.6.tar.gz
Running PIL-1.1.6/setup.py -q bdist_egg --dist-dir /tmp/easy_install-Fev48C/PIL-1.1.6/egg-dist-tmp-SNtCRu
In file included from decode.c:608:
libImaging/Zip.h:11:18: error: zlib.h: No such file or directory
In file included from decode.c:608:
libImaging/Zip.h:37: error: expected specifier-qualifier-list before ‘z_stream’
error: Setup script exited with error: command 'gcc' failed with exit status 1

try “aptitude install zlib1g-dev”. Thanks davisagli!

The previous procedure should work… But it didn’t in my system. :(  I get an error in the buildout.python bin/buildout:

SystemError: ('Failed', 'patch -p0 < /somepath/buildout.python/parts/readline-patch/readline.patch')

I’ve already tweeted fschulze (who is presumably the author of the collective.buildout.python stuff, according to comments in the #plone IRC channel) about this issue. I hope it will get solved soon! :)

In the meanwhile, removing or commenting out the stuff about readline.patch in the collective.buildout.python buildout.cfg before running bin/buildout appears to be a valid workaround, at least for me.

Check it out!

Some tips:

• Use Ctrl+K to get to the searchbar.
• With the focus in the searchbar Alt+Up/Down lets you select what search engine you want to use.
• While selecting an engine, typing a character makes you jump to the first search engine starting with this character. In our case, use ‘p’.

During the last Plone Conference the Plone Documentation Team was revived. It was time to start doing things The Right Way (TM). Our idea was to bind the development to the documentation, studying PLIPs after being approved by the Framework Team and updating and extending the documentation base accordingly before the new product version is released.

And finally, we did it for 3.3! So congrats to everybody who’s participated! I hope that in the future more people will chime in and we will improve our workflow for updating and testing changes in the documentation. Some ideas:

• We can’t publish (make visible to everybody) the documentation for the new version before the new version is released, because it will confuse people. Next PHC version will likely provide us Working Copy Support so we will be able to edit documentation “privately” while keeping the old (stable) version of a page public.
• We have to coordinate better with the PLIP implementors to write, review and verify the documentation. Proposed workflow:
  1. Make a list of affected docs. This list will likely include only documents in the official documentation area.
  2. Make a copy of them and find someone to document the changes. With Working Copy Support, thiw will no longer be neccessary.
  3. Ask the implementer of each PLIP to review the introduced documentation changes. Test them against a beta or release candidate release.
  4. After the final release, copy the contents of the copied articles back to the live ones, and delete the copies. With Working Copy Support, promote the changes to the public page.

Happy ploning to everybody!

1. Create the skeleton of the package using paster -t plone.
2. Add the package to your buildout.cfg, including the eggs, develop and zcml sections.
3. Define your type interfaces using zope.schema.
4. Implement the interface using Archetypes.
   1. Define the content-type fields using Archetypes.atapi.Schema.
   2. Bridge the getters and setters to attributes using atapi.ATFieldProperty.
5. Define the security policies for the class attributes throught <require /> directives into your configure.zcml.
6. Register the neccessary resources (images, css, javascript) into your browser/configure.zcml file, throught <browser:resource /> directives.
7. Implement the main view of the object.
   1. Register a <browser:page /> into the browser/configure.zcml file, referencing the view class and the content-type interface.
   2. Write the implementation of the referenced class above, using Products.Five.browser.pagetemplatefile.ViewPageTemplateFile and defining any internal methods that you’ll need into the rendered templates later.
   3. Write the associated template, using ZPT.
8. Write the GenericSetup install code for the new content-type:
   1. Register a extension profile into your configure.zcml, using a <genericsetup:registerProfile /> directive.
   2. Register the type into the portal_types tool throught a types.xml file.
   3. Specify the details for each type into the types/your-type-name.xml file.
   4. Write the __init__.py package’s boilerplate code to initialize the content-type and create the factory functions.
   5. Write down your configuration data into a config.py file.
   6. Assign add permissions to desired roles throught rolemap.xml.
   7. Register the type factory in the factorytool.xml file.

Thanks to Martin Aspeli for such a great book!