NOTE: This post is for installing Python 2.4 on a brand new Snow Leopard Instance. If upgrading on top of Leopard, you may have to update easy_install, macports, etc.  More Googling around may be required.

Though I had to create two buildouts to get this to work — is there a way to get this into one buildout?

I first tried to create one buildout by combining  Florian Schulze’s buildout recipe with a standard Zope recipe — but since initial bootstrap was run by Python 2.5, I couldn’t get the Zope instance to use the new Python 2.4. So I first ran a buildout to build Python 2.4 (using OSX-installed Python 2.5), then used that new Python 2.4 to run bootstrap.py on the Zope 2.8.x buildout.

Here’s the recipe I used to just build Python 2.4 (requires Florian’s buildout, see Alexander Limi’s comment below for where to find this):

[buildout]
#extends = src/snowleopard.cfg     # no longer required as Joe mentions below
python-buildout-root = ${buildout:directory}/src
parts -=
   ${buildout:python25-parts}
   ${buildout:python26-parts}

[install-links]
prefix = /opt/local

Then I ran a simple Zope 2.8 buildout to see if it would compile (using new Python 2.4 to bootstrap), and it did!

[buildout]
parts =
   zope2
   instance

[zope2]
recipe = plone.recipe.zope2install
url = http://www.zope.org/Products/Zope/2.8.9.1/Zope-2.8.9.1-final.tgz

[instance]
recipe = plone.recipe.zope2instance
zope2-location = ${zope2:location}
user = admin:admin
http-address = 8080
debug-mode = on
verbose-security = on

Here is my initial post:

I have to say — most everything I’ve installed on a fresh Snow Leopard install has worked flawlessly and swiftly — except for (the minor inconvenience of) iStat not working.  UPDATE: iStat 2.0 is available for Snow Leopard now. There’s a new beta of MenuMeters too for Snow Leopard.

There are also nice subtle improvements, see Mac Life’s 100 Top Snow Leopard Tips, Trick and Features for improvements to Preview, Expose, Stacks, etc.  I’ve very happy with the upgrade.

Now for the bad news for those like myself who depend on Python 2.4 for Plone, since many versions of Zope require Python 2.4.  I also use Python for Django, though that should run fine on Python that shipped with Snow Leopard.

You can read many of the initial details around the web, but here’s what I’ve experienced and have been able to put together:

• Note that these details are for a fresh Snow Leopard install – there are a different set of issues if you’re upgrading over your existing Leopard.  NEW: “Clark’s Tech Blog” has a nice write-up about upgrading Python after upgrading Leopard to Snow Leopard.
• Snow Leopard ships with Python 2.5.4, and this runs as a 32-bit application.
• I also need 2.4 branches of Python too, so I tried rolling my own (as usual) and it didn’t compile.  I then followed that thread for awhile.
• I then thought I pulled a fast one when I compiled from MacPorts and everything ran great!
• … but then I compiled Zope, and attempted to run an instance.  I saw a mysterious “No such file or directory” error.  Hmmm, I can navigate to that file, but running the script with my new Python interpretor was causing this error.
• After digging around with Activity Monitor, I discovered that the Python I built from scratch was running as a 64-bit app — while the Python that comes with Snow Leopard was only running 32-bit — which is telling, since most everything else on Snow Leopard is running 64-bit.
• Guessing that the the mysterious “No such file or directory” (when the file and directory did indeed exist) was due to a weird cocktail of 32-bit pieces living with 64-bit pieces.
• My latest theory was that I needed to figure out how to build Python as 32-bit.  I played with Macports and various architecture settings to hardwire this, but long-story-short — the architecture override isn’t used everywhere — so parts still compile natively as 64-bit on Snow Leopard.
• The best thread on the topic (that’s steadily growing) is here: http://bugs.python.org/issue6802 with msg92153 left today, which basically offers some additional settings for compiling Python as a 32-bit app (for Python 2.6).  Also mentions that Snow Leopard did some magic to get Python 2.5 working as a 32-bit app.
  
• My hope is that once “32-bit” Python 2.4 happens, the rest of the Zope install, etc, will be back to the good ol’ days in Leopard.

Plan B’s:

Otherwise, to save some headache, I’m wondering about installing a small Linux distro on VMWare as a local mini web-server where I can easily install Python and Zope — though that’s a bit of a pain too.

Luckily I also have my old Leopard in a separate partition (see my Extra life for my MacBook Pro with Snow Leopard and inexpensive hardware blog entry) and can boot that if necessary to work on various Zope/Plone sites (that required Python 2.4) while this is all being sorted out.

Now time to see if I can get 32-bit Python 2.4.6 compiled and installed, while waiting for more patches and information to appear…

Optimization Tutorial

I then got on my geek at “Faster Python Programs through Optimization” (Mike Müller of Python Academy), where we dove deeper into profiling and tips on improving speed or saving memory.

Some paraphrased guidelines to consider before you start optimizing (which were also reinforced in the “Real World Django” tutorial which I’ll chat about next):

• Make sure your program is really too slow – could be other factors like network traffic, database, etc.
• Don’t optimize as you go – might ultimately not need to spend that time.  Also working code is always important first.
• Only consider realistic use cases and user experience

We played with the profiling tools (profile, cProfile, time, pystone, heapy) and used them to compare various techniques:

• xrange and also Generators shaved off time by not having to allocate memory for large data sets.
• use built-in types as much as possible (including some newer collection classes)
• iterating and appending strings by first appending to lists, then using a join statement to create large strings (versus building strings via += and loops)
• One new one for me was converting lists to Sets before testing for membership of an item in the list, which is fast due to Set optimizations.
• The tutorial also covered pysco, processing and numpy modules, as well as caching techniques.

Real-world Django Tutorial

This very aptly named presentation by Jacob Kaplan-Moss and James Bennett was excellent for those of us who develop and deploy Django websites.  The full skinny (with link to slides) is here: http://jacobian.org/speaking/2009/real-world-django/

Some highlights for me included:

• Focus on tight Django Applications that promote reuse while also breaking a website into components. Benefits of also leveraging packaging up your own components.
• Gain flexibility by leveraging Django Managers, and they help encapsulate behavior behind an API.
• Can extend models via new (in Django 1.1) Proxy subclasses.
• Lots of discussion and recommendations for testing — from unit testing, through functional testing, and then browser-based functional testing. Yep, you need them all. I’d like to play more with Twill and Windmill.
• Automating deployment – including options like virtualenv (and virtualenvwrapper), Ian Bicking’s pip (“pip installs packages”), zc.buildout, and Fabric.  zc.buildout’s power was emphasized (with its recipes, etc) was a bit overshadowed by comments on lack of documentation. I’d like to give pip and Fabric a try.
• Apache + mod_wsgi is now a preferred platform for server Django sites (or at least much more consistent performance and memory-usage wise than Apache + mod_python).
• Definitely flip through the session slides!  These were just some highlights for me out of 189 slides of useful information.

Various tidbits for the next few days here at PyCon:

• Open Space sessions come highly recommended
• There’s a heavy testing thread throughout conference (10 sessions worth!)
• Friday 11am: Using Windmill
• Saturday 4:15p: Ian Bicking’s session (creator of PIP and virtualenv, among many other topics)
• Sunday 10:35a: Panel: Functional Testing Tools in Python
• … though it will ultimately be tough to pick and choose from all the great topics!

Time for some sleep… more tutorials tomorrow, then 3 days of conference, then 4 days of sprints!

ps: It’s been great to see familiar faces from the Zope and Plone communities, which is often where I “get my Python on”.  Lately I’m also doing a lot of Django, so enjoying all the synergy around Python here at PyCon2009!

A recurring conference theme for me centered around agility. Plone has benefited by moving from Zope2 to the more flexible Zope3 Component Architecture.  Zope technologies are being made available as middleware for use on other platforms (via Repoze and WSGI). Grok is a Zope3 framework for projects needing something more lightweight. There were several very useful sessions on Agile Project Management.

There are also continuous improvements making Plone more agile for end-users.  Plone 4.0 aims to make it even easier for end-users to manage their content (including better media support, unified widgets for easier page compositioning, “page centric”, kupu improvements around layout), as well as more through-the-web features done right!

Tuesday Arrival

On my Tuesday Amtrak ride to DC, I connected with some conference folks on Twitter, found my hotel and ended up at the Science Club for a few drinks and mini-reunions. Hotel Harrington wasn’t fancy, but clean, had wifi and was only two blocks from the conference and metro, so I was happy.

Wednesday

“10% Manifesto” was my first session. In Seattle, we’ve been holding a weekly Open Source Friday, which has a lot of parallels to discussions in this session.  We’re all practicing ways of putting that extra effort in to give back to the Plone community in which we all flourish, and also socialize and learn in the process.

I then caught up on the latest happenings with Ecommerce in Plone with the GetPaid project.  This is now being used for a variety of use cases, and its component architecture seems to make it relatively straight-forward to create modules for your own needs.

“When Software is a Service, Will Only Network Luddites Be Free” brings up an interesting question: What does a free [as in freedom and open] computing cloud look like? http://autonomo.us

Thursday

I started the day as a member of the “So you want to be a Plone consultant?” panel.  It’s a big discussion for a short amount of time, but we had a nice variety of panelists and good questions. Geir Baekholt’s discussion of Open Scope contracts peaked my curiosity.

One of the questions asked “How do project come into Web Collective?”  Clients often find us through our existing work with many progressive businesses and non-profits, our contributions of software and presentations in the open source community and Seattle Plone user group, and an interest in working with a company that practices a cooperative business model where all the members are owners of the company.

I was pleasantly surprised by a several tracks on Agile Project Management (“What makes a great development team” by Mike Robinson, and “High performance teams: What’s the secret sauce?” by Gerry Kirk on Friday).  Communication and project management often determine the success or failure of a software project, and tips and tricks in this area are always welcome.

Another interesting session was “Using Grok to walk like a duck” which covered several component architectures (from the limits of subclassing all the way through to the beauty of Adapters) and how Grok (and Zope3) support a dynamic version of Adaption.

After hearing about Deliverance 6 months earlier, “Using Deliverance to theme a website” was a nice way to catch up with the latest happenings here.  If you want to apply themes to multiple sites, this seems the way to go.

Friday

Experiencing some of the complexities and limitations of formlib, I wanted to check out Stephan Richter’s “z3c.form” session. z3c.form seems more refined, and can be used in in viewlets and portlets.

After talking with Jim Fulton at the Plone Summit at Google several months ago, I’ve been anxious to play with ExtJS, but haven’t had an opportunity.  Godefroid Chapelle showed us a rich browser solution using ExtJS and KSS.

“Repoze.bfg: A zope explosion” – Several months ago, we had the pleasure of bringing Chris McDonough to Seattle to talk about Repoze.  It was pretty new back then, and WSGI wasn’t something I had played with.  Since then, and after working with some other platforms such as Django, I was excited to catch up with the latest on this project.  The primary concept is to make Zope technologies available as middleware which could mix’n'match with other Python technologies via WSGI pipeline. In addition to the nice lightweight infrastructure, I think this highlights a longer term vision of being able to share best-of-breed Python technologies across various Python frameworks.

Saturday and Sunday Plone Sprints

Record turnout of people at the Plone sprints!

I was happy to collaborate for a couple of days with Aaron VanDerlip on Plone4Artists Calendar.  I had used this on a recent project, and wanted to help make improvements to what’s becoming a defacto solution for Plone calendaring, including an implementation of recurring events.  I’m relatively new to the project and have been impressed with the product’s architecture and its recent 2.0 alpha release.  I enjoyed lending a hand to help fix bugs and refining some functionality.

I also though the concept of a “Beginner Sprint” was ingenious and helpful for including new people in the community and getting them up and running with everything they need. Nice work Jon Stahl and Joel Burton (and other Plonistas that participated).

Monday, Heading Home

Then a perfect ending — I lucked out on a direct flight to Seattle (pays to get to the airport early) and ended up sitting right next to my friend and fellow Plone collaborator Andrew Burkhalter.

After Web Collective just finished a Django website that needed to scale to 12,000 simultaneous peak users, Flickr architect Cal Henderson’s keynote was timely and very entertaining – particularly his commentary on “serious” frameworks and essentially a comic roasting of all of the major ones.

Since most of us are building “houses and not skyscrapers” there is some question as to whether Django should introduce all of Cal’s suggestions (who is a “scale” geek working with on a very large website), but how can you argue with his three major focus areas of scale, performance and “being awesome“.

Discussions of “scale” and “Django” remind me to play with Google App Engine soon. I also just discovered Django Debug Toolbar and other interesting things reading through Cal’s blog.

Learning from other Python Frameworks (Django and Zope)

With Zope (and Plone) being the platform I’ve used for some time now, I found Mark Ramm’s perspective on how to learn from all the smart folks in various Python (and other) frameworks a good 10,000 ft reminder.

He highlights that Zope3, Turbogears, and Pylons have learned some of the lessons of old Zope2 in that they are frameworks that strive to use community components that work with each other in multiple contexts.  They also are trying not to isolate themselves from the Python web community by building functionality specific to just one platform.

He wasn’t saying Django was far afloat in these areas, but rather that Django could make some of its innovations available more easily to other frameworks (e.g. Django’s ORM, and Django’s template engine), and that it should maybe use some of the Python components from other frameworks (e.g. Django middleware and WSGI middleware compatibility).

I look forward to poking around the rest of the DjangoCon 2008 videos, such as Guido van Rossum’s keynote and others on YouTube’s DjangoCon 2008 Session’s playlist.

I had planned to create this blog using the latest Quills 1.6 trunk to learn both about blogging and “blogging on Plone” — so downloaded and gave it a try. It installed ok on Plone 3, but I ran into errors posting blogs and playing with the portlets — to be expected during early beta testing.

I’m also intrigued with QuillsEnabled (currently in alpha) – which leverages the Quills family of products, but takes the approach of adding blog functionality to ordinary Plone content. This pattern is also used in Plone getpaid to allow ordinary Plone content to be marked Payable so that it then takes on additional functionality such as a price and a way to add the item to your shopping cart.

I’m looking forward to following the progress of Quills (nice work Tim Hicks!), and as things become more stable I envision my next blog projects using Quills.

In the meantime, I look forward to learning more about blogging and blogging software through WordPress, which is an impressive and fun blogging solution.