The requisites

The client wanted a system to manage and organize online photo and video competitions. The competitions’ announcements and rules would be published in the site. The people who wanted to participate in a certain competition would register on it, entering their personal data, and then be able to submit photos and videos to be evaluated for the competition.

Participants should only be able to see their own submissions, and never the ones from the other participants, until the submission time is finished. The judge of every competition, a group of designed people, should be able to see all the submited items, but not their owners. The members of the judge should also be able to rate or reject each submission.

The participants shouldn’t be able to edit or add elements in the rest of the site, only in the competions they had signed up, and the sign-up form should look like if they were signing up for a competition, not like if they were creating an account for a normal Plone site.

The proposed solution

This is how we decided to implement the product in Plone. Surely there might be smarter ways, so comments to improve the product are appreciated. :)

First, we decided to create a folderish Archetypes content-type to represent a Competition, with classic title and description, and rules. Folderish because it would hold photos and videos. The photos would be just a copy of the Image type, and the videos of the File type, perhaps including some integration with p4a. Having special Photo and Video content-types ensures we can assign a custom workflow to them, as we actually need.

To ensure that the participants can only see their own submissions during the competition submission period, we create a special workflow for them, competition_item_workflow, with three states:

• Private: The participant is still preparing the item. Only he can see and modify it.
• Pending: The item is waiting for the judge evaluation. The participant can’t modify the item anymore. The judge can see and evaluate it now.
• Published: The competition has ended and the items is marked for public display.

Only the participant (the owner) can trigger the submission of an item, and the judge can publish it later, which is implemented using role guards in the respective transitions.

Competitions themselves also have a dedicated workflow, competition_workflow, with states:

• Private: In preparation. Can only be seen by the owner and the users he/she allows manually.
• Open: The rules are published and participants can sign-up and submit their works.
• Closed: The competition doesn’t accept new work submissions and the results are published.

Since a single person can participate in more than one competition, we decided to make the participants create a user in the site and sign-up later in each competition individually. To do so we:

• Create a customized copy of the Plone join_form, with fields for location, phone number, and other personal data they need to enter when they sign-up.
• Customize the Competition view to include a “Sign-up for this competition!” button, which would grant the “Competitor” local role to the user, which in turn would grant him rights to create and submit items for the competition.

To hide the author info from the judge, we customize the plone.documentbyline viewlet to hide it for users without the Modify portal content permission over an object. It’s not the most optimal solution perhaps, but it just works for now.

The judge for each competition is assigned manually for the managers of the site, assigning the “Reviewer” local role to individual users via the Sharing tab.

The rating is implemented via plone.contentratings. We created a custom category with a custom rating manager, since the default one wasn’t working properly with the permission settings we set for rating and reading the ratings: competitors and the judge can’t see the ratings of submissions before the competition is closed, and the judge can only rate works while the competition is open.

In short, Deco is a page composition system based on semantic HTML and a grid system. Instead of using custom XML namespaces and a templating language (like METAL), Deco uses plain (strategic) HTML.

To add this feature to a Dexterity content-type you just have to add the plone.app.layoutbehavior Dexterity behavior to it. This behavior adds two fields to the content-type: layout, to select the site layout you want to use, and content. This last field will contain all the tile-related HTML markup, and is populated by default with two field tiles: title and description. The Dexterity type with the cited behavior we’re currently using is named Page and lives into plone.app.page.

If the Deco UI package, plone.app.deco, is installed, it will detect the presence of the content field and activate. The Deco UI allows you to insert, drag-and-drop, edit and delete tiles inside the content field of a type.

To position the tiles in the screen, the Deco UI makes use of the so-called Deco Grid System, a bunch of carefully crafted CSS classes that, when applied to div elements, position them in the page with the appropiate dimensions.

Tiles are little more than browser views with associated configuration data, and their base classes live in plone.tiles. We have transient tiles, which store the configuration data in a querystring in the tile HTML, like:

http://host.org/@@plone.app.standardtiles.helloname/tile-1?name=Israel

and persistent tiles, for config data not encodeable into querystrings (e.g. a large file), which store the data in the ZODB as annotations in the content object. Note the expected ‘@@’ for browser views — when this URL is accessed, it will return an HTML page with headers and a body, like:

<html>
  <head>
    <link rel="stylesheet" type="text/css" href="names.css" />
  </head>
  <body>
    <p class="aName">Hello Israel!</p>
  </body>
</html>

The plone.app.tiles (notice the “app” namespace) package registers the helper views @@add-tile, @@edit-tile and @@delete-tile to do exactly what their names say, the two first ones using a form generated from the tile data schema via plone.autoform.

So how are tiles actually rendered into a page? The answer resides in plone.app.blocks. This package is in charge of loading the page layout (remember the “layout” field added by plone.app.layoutbehavior?), merging in the contents of the page and “expanding” the tiles, merging the head of the tile into the head of the resulting page and putting its body where the placeholder for the tile was, as detailed in the documentation.

Finally, the basic tiles to be inserted, including image, video, attachment, navigation tree and searchbox among others, live in plone.app.standardtiles.

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.

Just mix the following ingredients together, for 3 people:

• 1 iceberg or roman lettuce, chopped.
• 1 or 2 carrots, sliced.
• 1 apple, diced.
• 100 g canned corn.
• Feta cheese, diced.
• Basil and olive oil for the dressing.

You can add some salt if you like so, but the feta cheese is usually salty enough. The apple gives the acid touch, so you don’t need vinegar.

Thanks Ana!

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.

Below you can find some notes on the ones I participated in.

Hacking the Hill

This workshop was about who you should contact if you want to influence the political decisions in your state inside the USA. People usually contact their most local representative, but what is important is to influence the representatives who are part of the committees where the topics you’re interested in are discussed.

The most effective method to influence their decisions is to ask them for a physical appointment and talk to them to explain your point. They don’t directly watch their heavy-loaded mail account nor Facebook (:P), but conversations can change minds!

Opensecrets.org is an amazing website where you can find a lot of data, mainly economic, about politics, politicians and lobbies. Under Politicians & Elections → Congress you can find a list of the current representatives, and if you click on their names, the committees assignments.

On the Spanish side, the Hacktivistas group maintains a very interesting wiki page where who is who in the Copyright politics game is described. Also, they’ve recently published an article about the anatomy of the Special 301 Report lobby.

Charter for Innovation, Creativity and Access to Knowledge

This workshop versed about the already (I hope famous) Charter authored during the 2009 Culture Forum in Barcelona. While we often are tempted to point out the bad and worse stuff of the current legislative initiatives, this Charter aims to be a positive reference document for discussing Copyright, A2K and Net Neutrality topics.

It is the work of more than one hundred experts and it’s always being improved. The current version 2.0 has been endorsed by dozens of individuals and organizations, some of the most popular listed at the end of the Charter.

Michael Johnson pointed out the existence of a similar document, the Libre Society Manifesto, by David M. Berry and Giles Moss. While (IMO) the purpose of this last document is different, I’m sure we can take ideas from it to include in the Charter, and of course welcome the manifesto’s authors to join us.

During the presentation we had a very interesting conversation with one of the attendees, a photographer who was publishing her work under CreativeCommons licenses. She told us that she usually faces problems with her clients since they’re not used to this (new?) way of publishing photos, and they often look for sole rights.

We arrived at the conclusion that this open-licensing is opening a new model of payment orientation: whereas the closed-licensing (all rights reserved, can’t copy nor redistribute, etc.) built the value around the content, the open-licensing is building the value around the work itself. Instead of paying for a piece of content, you pay the people who create this content to create it.

While it can sound rather new, this has been the most natural model in the Free Software world for a long time now. Since most Free Software is provided free of charge, as a consultant you can only charge a client for the work you have to do in order to adapt and customize it to his needs. One usually releases the resulting product, when appropiate, as Free Software, so instead of having to reinvent the wheel over-and-over again, other people can just pick up your work and extend it, which is much more efficient.

For example, I work with Plone, a Content Management System widely used in government-related and NGO sites. The amount of time the Plone contributors have spent on it must be really impressive, but it’s provided free of charge, gratis! This is sustainable because we use Plone to build websites, and the better and more powerful Plone itself is, the easier it is to adapt it to the customer needs, and so the more clients that are willing to hire these skillful developers.

This also encourages a new strategy to develop products: instead of developing the product and hoping to be able to sell it to enough clients to compensate the investment, you wait until customers have commited enough funding for the development. This way you have sold the product before developing it and therefore reduces the risk of supreme failure.

Open Educational Resources tools

The open.michigan team presented the dScribe framework to extract atomic content from existing material, edit its metadata, clear copyright issues and create new material. They told us that the software powering the framework is still a bit hard to install, since it was developed to work in the Michigan University, but they can open an account in their servers for you if you ask them.

One of the problems we’re facing is how to create, maintain and publish the contents in a way they’re easy to comment and contribute to and, at the same time, high quality. One of the most advanced tools to generate high-quality documents is LaTeX, but the way it works makes it a bit hard to be converted to HTML and published in the web, where contributing is much easier and accessible than having to dive into the LaTeX source.

In this sense, Alqua is investigating plasTeX, a modular and very extensible LaTeX document processing framework written in Python. The aim is to be able to publish LaTeX documents in HTML and provide a per-paragraph and per-formula comment system like the one you can see in the Mercurial Book.

Another approach is to use a markup syntax and a wiki-style site to compose and comment the document and make use of some scripts to convert the markup to LaTeX when generating a high-quality and ready-to-print version of the content. The testing/beta veresion of Wikipedia already allows you to generate a beautiful PDF-book from a set of articles of your choice, so it’s clear that this approach is reasonable.

FLOSS in scientific education

The goal of this workshop was to ask the attendees about the approaches to free software taken in their educational environments, related to Science.

A lot of universities are using and teaching their students to use privative scientific software, like Matlab, Maple or Mathematica. These universities often have to spends huge amounts of money on multi-PC licenses for the software, or even encourage students to install non-original copies of the software in their PCs. Moreover, the internals of these software pieces are hidden to the students, in clear contradiction with the scientific spirit.

There already exist quite a lot of Free Software replacements for the privative counterparts, like you can check in the Open Source as Alternative website. One of the most interesting emerging frameworks is Sage. As their developers define it, it is a free open-source mathematics software system that combines the power of many existing open-source packages into a common Python-based interface.

The combination of different packages provides the most efficient way to deal with each type of problem and warrants interoperability. For example, Sage can use Maxima to solve a differential equation symbolically and Matplotlib to plot the results, all under the hood.

Another impressive and very convenient feature of Sage its Through-The-Web interface. You can set-up a web server for some students to use Sage in a collaborative environment from their own homes without installing anything on their computers. Try it and break your jaw at the Sage Notebook website.