Ross Patterson's Blog - Posts tagged Tahoe Sprint 2010

Cioppino Sprint

2011-06-13T00:00:00+00:00

I’m back home after the west coast sprint formerly known as the Tahoe sprint, plone.net is now on plone.org, and I can spell Cioppino without looking it up.

Last night I got home from the Cioppino Sprint in beautiful Bodega Bay, CA. Steve McMahon did an excellent putting arranging the sprint and got us a vacation house with a stunning view and a hot tub. Combine all this with a few great cooks and California fresh produce, we ate well, enjoyed the view and got a lot of coding done.

The sprint was focused on “achievable tasks that provide immediate wins for Plone-the-product or Plone-the-community”, meaning low-hanging fruit mostly on the plone.org site itself. With Limi, I took on merging the plone.net service providers site into plone.org itself. For my part, this involved:

updating Products.PloneServicesCenter to Plone 4 along other fixes, cleanup and improvements

exporting the content from the plone.net then importing it on plone.org

doing a few selective catalog updates

re-creating some content

setting up some content rules

Pretty easy stuff and it was mostly done by Friday. It was also the first time I got my hands on plone.org itself. Call me a fan-boy but I still get giddy when I get one step closer to the core of Plone, a project I was once totally on the outside of.

I also spent some time walking through the creation of a new custom AT content type with Bill and Spanky to see how hard it is to approach this task as a newcomer to Plone. I always enjoy helping get started and happily, Bill even posted his code to github.

Not to toot my own horn, but my mixology seems to have been a hit. My Manhattan was particularly popular and since Bill Deegan asked, here’s the recipe:

Cioppino Manhattan

1.5 oz      Buffalo Trace Bourbon (good bang for buck, not quite top-shelf)
1.5 oz      Carpano Antica Formula (really good sweet vermouth)
1-2 dashes  Blood Orange Bitters

Stir with lots of ice for a good while to melt plenty and mellow
out the cocktail.  Strain and serve.

In summary, the Cioppino Sprint was quite a success, I had a great time, and I very much hope it becomes an annual tradition!

Updated on 13 June 2011

Imported from Plone on Mar 15, 2021. The date for this update is the last modified date in Plone.

TTW Dexterity Vocabularies

2010-03-19T00:00:00+00:00

First report from the Tahoe Sprint working on user-enterable vocabularies in the schema editory.

So I’m here at the Tahoe Sprint thanks in part to a generous sponsorship by WebCollective. Thanks WebCollective!

This is the first year of what I hope will be many Tahoe Sprints and was focused on Dexterity. I decided to start by trying to implement TTW field vocabularies for the plone.schemaeditor TTW Zope 3 schema editor. The plone.schemaeditor is a generalized approach to TTW schema editing and does not depend on Dexterity but is at the heart of Dexterity’s TTW content type support. It had basic support for defining a few simple fields and adding support for user-selectable or user-entered vocabularies or sources seemed like the next step.

For those not familiar with Zope 3 schemata, fields that support choosing from a set of values can use either vocabularies or sources. Vocabularies are the older approach and are, roughly speaking, more suitable to simple sets or sequences of selectable values. Sources are a newer approach and are, roughly speaking, more suitable to complex choice behaviors such as searching for items to select, or choosing from very large sets of values where more conventional listing would not scale.

We discussed the various things one might want to do with specifying vocabularies or sources for fields. The simplest, and probably most common case, is where the user simply wants to enter the list of allowed values and have a simple selection widget presented when the field widget is rendered. For more complex sources, each source will have it’s own implementation specific set of options for the user to configure when creating the fields and as such each source will need it’s own add/edit form in the schema editor. We also discussed the possibility that users creating/editing schemata may want to re-use the same vocabulary or source across multiple fields, where those fields may themselves be in different schemata. Given all that we decided it was best to implement only simple vocabularies with a list of user-entered values on the field edit form and tackle the shared vocabulary and source support as a registry of vocabularies and sources that could be assigned to choice fields.

On the first day (well the first day not spent driving and socializing), I was able to get user-entered vocabularies working for single selection fields, labeled “Choice” for now in the schema editor. Early on the second day I finished user-entered vocabulary support for multiple-selection fields. If you’d like to take a look at it, fire up the dexterity development buildout and try it out.

Updated on 19 March 2010

Imported from Plone on Mar 15, 2021. The date for this update is the last modified date in Plone.

AT Relation Field

2010-03-19T00:00:00+00:00

Working with David Brennan on two-way references and relationships

between Archetypes and Dexterity.

Next to the method for defining content type schema and installing content types in a portal, the Archetypes reference engine has been one of the more valuable and widely used bits of Archetypes. Unfortunately, the AT reference engine is also a bit heavy weight and too tightly coupled to AT, making it hard to re-use fruitfully.

The zc.relation package provides a very powerful library for establishing connections, read references and relationships, between objects. It also provides for walking and searching networks of connections. It’s all very cool. It’s also very generalized which is a good thing since it can be used in so many different ways. This does, however, make it very difficult to approach. It’s my hope that as we find ways to integrate zc.relation into the Plone stack, that others will find clever ways to use zc.relation’s powerful network traversing to do some unexpected things. So the combination of zc.relation and z3c.relationfield provides not only a more widely re-usable, loosely coupled replacement for the AT reference engine, but a much more powerful tool with capabilities far beyond what could ever be achieved with the AT reference engine.

One of the concerns which kept coming up was that getting rid of the AT reference engine meant getting rid of UIDs. With UUID use taking off and finding new and interesting uses it’s important that we provide some sort of UUID system, but the AT reference engine is large and heavy and very much unnecessary to support UUIDs. UUIDs are very simple and should not be coupled to any particular framework or larger library when they can so easily be a very small library of their own easily integrated in lots of ways. So the question of how we want to support UUIDs and the question of what to do with the AT reference engine should no be conflated, they can and should be addressed separately.

Dexterity integrates the z3c.relationfield package to provide widgets for specifying zc.relation connections between content on z3c.form forms. This allows Dexterity content to establish relationships and references to both Dexterity and AT content. There is, however, no zc.relation field and widget for AT content so there’s no way for AT content to establish relationships or references to Dexterity content.

David Brennan set out to build an AT field and widget that could make use of zc.relation relations and on the latter half of the second day I joined him for some pair programming. By lunch on the third day, we had working extensions of Products.Archetypes.Field.ReferenceField and Products.Archetypes.Widget.ReferenceWidget which used zc.relation behind the scenes.

Next up is an extension of Products.ATReferenceBrowserWidget which works with zc.relation. Once that is working, archetypes.schemaextender can be used with one which uses zc.relation. Finally, a migration can be to offer a ZCML file which would replace the ATCT relatedItems field implemented to migrate existing AT references to the zc.relation back-end.

Once that is completed archetypes.z3crelationfield can be used as a proving ground for the possibility of removing the reference engine from Archetypes itself. Once it’s polished and the AT reference engine removed, the way will be paved to remove one of the hurdles which has made it so hard for newer content type frameworks to make an entrance on the Plone scene.

Updated on 19 March 2010

Imported from Plone on Mar 15, 2021. The date for this update is the last modified date in Plone.