He started with a brief history of Zope2, how it started, how the CMF came up, introducing new concepts, like Filesystem development, Skinning support and a standard set of tools.

Zope3 was then meant to overcome problems in Zope2 and the CMF. Development started in 2001 and aimed to be a “Zope for developers”. It was a complete rewrite and complete redesign. In the meantime Plone and other projects such as Ruby on Railes and others raised in popularity.

The business view

If you are a company it is important to get paid for your programming work. You will always have a technology lag though because you usually cannot be always on the cutting edge with all people. You try to differentiate yourself from the market by IP, packaging up your software etc.

But don’t bet your business on it!

(didn’t get the rest though unfortunately)

Is Zope right for you?

What is available? Plone is out there but migrating Plone versions is a pain but might get better.
You can also use CMF and Zope2 to have more flexibility but in fact you maybe directly should look at Zope3 but maybe not the whole thing directly.

Reasion: The Joy of using Python.

Don’t Panic!

Zope3 is big but not complex. It just is different and it takes a while to get used to it.

Some figures: Plone objects have about 750 attributes when you instanciate them, CMF objects about 350, Zope3 objects about 50, mostly less. The less attributes you need to understand, the better.

What’s good about Zope3

First: No acquisition. Back then it was quite a great invention in a CGI environment but unfortunately acquisition can have unpredicted sideeffects (esp. regarding security). In Zope3 it has been removed and you might need to get used to it.

The basic principle: Explicit is better than implicit.

Zope3 also has the Component Architecture which is great in itself but sounds rather complicated. The amount of configuration probably is what keeps people away from Zope3 right now. But configuration also has it’s benefits because programmers and computers know exactly about what’s going on here.

One question: Do I need components in a one-off site? This is a loaded question which can create a lot of discussions. But when you use it you can later get a lot of flexibility. Also remember that maybe in your next project you might want to reuse part of what you did for the one website. Using components then makes it easier.

Everything is an interface

One of the key concepts is an Interface, which is not just a specification but also a membership card. It’s a way to get to stuff.

Documentation considered harmful?

Documentation for Zope3 is right now in READMEs mainly. It is unfortunately not as well documented as other projects which is a barrier of entry for many people. The code is readable but some of the concepts are somewhat abstract esp. for people who never used adapters etc.

But there is a great book: Web Component Development with Zope 3 by Philipp von Weitershausen. For Plone there is of course Martin’s book which also explains parts of Zope3 like adapters etc.

Zope 3 in 5 minutes

1. Write your interface
2. Write your content type
3. Configure your content type
4. Views
5. Configure your view

Our experience

• PHP programmers can migrate to Python
• HTML developers are very happy with ZPT
• Allow two months to transition

He then demoed a simple reimplementation of a Plone document type with Zope3 mechanics. He defined an interface, create a content type which derived from PortalContent of the CMF and configured it. He then showed the browser part of it where the views get defined.

(this transcript comes without any guarantee for correctness)

From today on you are able to register for the Plone Conference 2008, held in Washington, D.C. from October 8-10, preceeded by Trainings (Oct 6-7, to be paid separately) and followed by sprints (Oct 11-12).

The Early Bird price is US$ 500,- (EUR 317,- with todays rate) and Early Bird end on August 01. After that it’s US$ 550,- (EUR 349,-).

To register click this link!

And for all information about the conference click here!

See you in Washington! :-)Technorati Tags: ploneconference2008, plone, registration, conference

The Plone Conference 2008 is looking for sponsors! If you want it to be a rocking conference, then consider being a sponsor.

This time also individuals are able to be a sponsor in one of 4 categories (starting at US$100). So come and join Google and others and be a sponsor!

For all information just click this link!

Technorati Tags: ploneconference2008, plone, sponsoring

Hans Rosling, professor of International Health at Karolinska Institutet and co-founder of Gapminder Foundation, will be holding one of the two keynotes at the annual EuroPython conference this year!

If you don’t know Hans Rosling, I would advise you to watch the two talks he gave at the TED conference or simply coming to this years EuroPython which will happen from July 7-12 (conference is going to be from monday to wednesday, followed by sprints). Hans Rosling will be speaking on Tuesday evening before the Conference Dinner.

What I like about him is his great presentation style from what many people could IMHO learn a lot (although it probably also does not fit everybody). But it’s not only that but it’s also the topics he talks about, like economic, social and environmental issues of Africa, what he was talking about at TED. So for these two things I am very much looking forward to this keynote.

And if you are still unsure whether to come or not: As compared to TED you don’t need a special invitation and you don’t need to pay US$6000,- but only EUR 160,- (Early Bird is over unfortunately). So isn’t this one more reason to come?
(and thanks to Lennart Regebro for initiating this!)

Here is the second TED talk:

(link to the video)

Technorati Tags: europython2008, europython, hansrosling, ted, africa, keynote

This was a good solution but had it’s drawback in the redirect because it was an additional hit on the server and does not play too well with caching. A better solution would be to “compile” those links when saving a page and updating it should a linked page change (which should be possible with today’s events) but unfortunately to make this work like this is a lot of work.

So in order to get rid of these resolveuid-Links in the HTML source I wrote a little method which resolves them when creating the HTML content. This takes more time on read but this time is needed anyway later on in the subsequent call of the redirect. It even does not have the HTTP overhead.

So here is how it looks:

First we need a regular expression to find those links in the source:

import re
expr=re.compile("resolveuid\/([0-9a-f]+)",re.M)
</pre>

Next I created an additional method in that Archetype object which resolves these URLs in the "content" field (this depends on your type, it could also be done inside a view of course):

<pre>
    def getContent2(self):
        """returnt he content"""
        from Products.CMFCore.utils import getToolByNameTechnorati Tags: <a class="performancingtags" href="http://technorati.com/tag/plone" rel="tag">plone</a>, <a class="performancingtags" href="http://technorati.com/tag/uid" rel="tag">uid</a>, <a class="performancingtags" href="http://technorati.com/tag/kupu" rel="tag">kupu</a>, <a class="performancingtags" href="http://technorati.com/tag/links" rel="tag">links</a>
        reference_tool = getToolByName(self, 'reference_catalog')
        map = []
        content = self.getContent()
        uuids = expr.findall(content)
        for uuid in uuids:
                obj = reference_tool.lookupObject(uuid)
                if not obj:
                        return ""
                target = obj.absolute_url()
                source = 'resolveuid/'+uuid
                content = content.replace(source,target)
        return content

In this case I created a second accessor method called getContent2() which I call in my skin.

This should help you then with unneeded redirects. Of course there are better solutions esp. if you think about this issue from the beginning but this quick fix should help.

These days btw. there’s the Redirect Tool which automatically remembers renamed/moved page locations and redirects from the old to the new location. This should be better in case you don’t move things but for moved pages you still have redirects then. So to me the best solution would still be a notification of the source object to update itself.

(or click this link if you cannot see the video)

Technorati Tags: plone, books, seesmic

If so, then please sign this petition which calls for using Open Standards, more competition and no vendor lock-in for the EU parliament! Read the full petition here and please sign it here!.

Please help to promote Open Standards and Interoperability!

(via ZEA Partners)
Technorati Tags: dataportability, openstandards, eu, parliament, petition

• XFN for marking up your contacts
• hCard for marking up your profile information
• RDFa for e.g. marking up Dublin Core Metadata and similar information (I wonder if we do that in Plone, I guess not but we probably should as we already store a lot of DC Metadata).

This is once again great news and a good next step in making Data Portability happen! We need more of this!

In other news I added two new technical recommendations to the Technical Specifications of the DataPortability Project. Those are specifically about how to markup profiles (hCards but some bits are missing with this) and contact information (here I think we should allow for both, XFN and FOAF). Please comment on them or add issues to clarify.

You can see all the technical recommendations here.

As said, please participate! Join an Action Group! Or if you are running a social network add these technologies to your site, too!

The last few days I have been working on creating the basic parts of a DataPortability library for Python. My goal is to create a library which supports the standards we propose in the DataPortability Project to help leveraging Python based implementations. It of course also might be useful without this aim in fact you might simply need a library for handling microformats or one of the other standards.

Right now the library is very barebone, supporting basic parsing of the hCard microformat, the XFN microformat and XRDS Simple. What comes out of the parser are then VCard, XFNRelationships or Service objects, depending on which parser you use.

Please note that all this is still very raw and very far from being complete. See this as development version, stuff might still change a bit. Documentation will also be added shortly.

Here is a list of eggs available:

pydataportability.microformats.base

The parser class handling the main work. It containts two HTML parsers right now (BeautifulSoup and ElementTree) and aims to be as extensible as possible. I use the Zope Component Architecture (ZCA) here for making this happen (note that it does not mean that it’s a Zope Application, the ZCA is a small but very useful part of Zope and allows me to register components in a decentral way. I will add examples later when I write more documentation.

PyPi entry.

pydataportability.microformats.hcard

The hCard parser which registers with the base package. If this is imported it will automatically try to find hCards in HTML documents

PyPi entry.

pydataportability.microformats.xfn

The XFN parser which registers with the base package. As the hCard parser it will automatically try to find XFN relationship inside an HTML document

PyPi entry.

pydataportbility.xrds

This library parses XRDS Simple formatted files using ElementTree and returns Service objects

PyPi entry.

pydataportability.examples

This egg is mostly useful in an example buildout and creates some examples scripts in it’s bin/ directory (see example below)

PyPi entry.

An example

To show how it works I created an example buildout. If you don’t know what an buildout is then don’t worry, you don’t need to know for the example (basically it allows you to create a sandbox and install various eggs in it. Very useful for developing in a group or deploying software. Check out this screencast for a demo). In case you don’t know what Python eggs are, then please read my tutorial on them.

So here is what you do to get the examples working:

1. Download the examples package.
2. Extract it using tar zxf pydataportability_examples-0.1.tgz
3. Change to the directory using cd pydataportability_examples-0.1
4. Run the bootstrap.py file: python bootstrap.py (this will download the necessary software for the buildout to work)
5. Run the generated buildout script: bin/buildout (this will download all the pydataportability eggs and installs the example scripts in bin)

Now you have 3 example scripts in the bin/ directory. To run them just call them, e.g.:

bin/xrds
bin/mf_etree
bin/mf_bsoup

The first one parses an XRDS file and returns the found objects, the others parse the contents of my twitter page (which contains microformats) and return the found microformat objects. One uses the ElementTree parser, the other the BeautifulSoup parser.

Where is the source?

The simplest thing to get the source is probably to get the source buildout and build it (you should be somewhat familiar with buildout though). Just do this:

svn co https://pydataportability.googlecode.com/svn/buildouts/microformats pydataportability
cd pydataportability
python bootstrap.py
bin/buildout

This will create a development sandbox. You will find the same examples in bin/ and you will find the source eggs in src/.

The source can also be found in SVN, just look at the Google Code page for it. Everything starting with pydataportability. is part of it.

Make also sure to read the README in the example buildout.

More documentation will be added later (as soon as Google re-enables wiki editing). There is also a Google Group for discussing pydataportability.

Technorati Tags: dataportability, pydataportability, announcement, python, development

As you also might know there was some discussion about how to approach the DataPortability problem space and one of the ideas which came out of that was my idea of dividing it into fields and levels. Now this general discovery use case nevertheless makes much sense because it seems to be a general starting point for every field we might address. So how does it work?

Doing discovery

Imagine you signup for a new social network and you want to import your data from elsewhere. The most important part now is to find out where data is available for you. Of course you can enter a set of URLs but I guess we agree that this is not particularly user friendly.

The service catalogue

Thus the idea of a service catalogue was invented which contains all the locations and types of information you have on the web. This service catalogue can be an XRDS file, following the XRDS-simple specification. Such a file could look like this:

      <XRDS xmlns="xri://$xrds">
          <XRD xmlns:simple="http://xrds-simple.net/core/1.0" xmlns="xri://$XRD*($v*2.0)" version="2.0">
              <Type>xri://$xrds*simple</Type>
              <Service priority="10">
                <Type>http://www.w3.org/2006/03/hcard</Type>
                <URI simple:httpMethod="GET">http://pownce.com/mrtopf</URI>
                <LocalID>jane<LocalID>
              </Service>
              <Service priority="20">
                <Type>http://gmpg.org/xfn/11</Type>
                <URI simple:httpMethod="GET" priority="10">http://twitter.com/mrtopf</URI>
                <URI simple:httpMethod="GET" priority="20">http://pownce.com/mrtopf</URI>
                <LocalID>janedoe<LocalID>
              </Service>
          </XRD>
      </XRDS>

In this example the endpoint for an hcard and an xfn list are defined (if I actually understood xrds right, I only skimmed the spec and changed the example. Also the types might not be correct).

The workflow

So the flow we are discussing is like this:

1. A user logs in with her OpenID (this might involve retrieving an XRDS file first which describes which authentication mechanisms are actually available and under which URLs. This is also known as YADIS and part of the OpenID 2.0 specification)
2. The network asks the OpenID provider for the location of the service catalogue which is an XRDS file as described above. It does this via the Attribute Exchange extension of OpenID (AX). This XRDS file can additionally be protected by OAuth to allow more control by the user who got to see it.
3. The network then processes the list of service types it found in the XRDS file and can retrieve the information available there. These ressources can be protected by OAuth as well so that e.g. not everybody is able to look at your friends list.

While this workflow seems simple of course not all open questions are answered. E.g. it is unclear how the AX part might work as it seems that it’s not widely used and not many examples are around. The question is also what benefits it has over existing standards (like hCard). There is also the question if there might be alternatives to using AX to retrieve the service catalogue location.

So there are some discussion points open but I guess we can solve them quite quickly. What is obvious here though is that we really try to reuse existing standards instead of defining our own. OpenID, OAuth, XRDS (and simple), AX, hCard, XFN etc. are all available already although maybe sometimes an implementatin is missing. But the hope is that DataPortability will also give an incentive to create such libraries.

Plone and DataPortability

My plan is to try to implement these things for Plone. Right now I am working on a microformats parsing library for Python (more on that later) and my plan is to get OAuth and XRDS in Plone working. I am not sure yet how to solve the AX part because apparently some OpenID provider implementing this is needed (beside that I have no idea about how AX works yet as there are simply too many standards out there which need to get read).

What it also means for Plone is maybe a different way of handling OpenID. Right now there is no way to attach an OpenID to an existing user/profile. Instead they are separate (somewhat virtual) users. This eventually means adding a different OpenID implementation to Plone which allows people to attach one or more OpenIDs to their user accounts.

Another question is if Plone should become an OpenID provider, too. OTOH there are already too many out there. So it might depend on how much work it is.

Having OAuth in Plone is not only interesting for DataPortability but for any means of accessing data from the outside in a controlled fashion and as a basis for other web services.

So all in all I hope we get very fast going with this first use case so that people know what to implement.

Technorati Tags: dataportability, london, plone, xrds, openid, oauth