See also...: Plone.org: Announcing Usuarios Plone Mailing List Jan 09, 2009; Jorgen Modin: Plone login portlet and the personal bar could be the same thing Jan 09, 2009; Gerry J Kirk: The perfect first job for helping out the Plone community Jan 09, 2009; ifPeople: Plone makes Econtent 100 List for 2008 Jan 09, 2009; Josh Johnson: What have I done? (website screen captures/thumbnails in python and a lot of shell commands) Jan 09, 2009; More…

Introduction

I have a tutorial/development methodology I’ve developed that walks the uninitiated plonista through a crash-course of plone 3 development. I’m going to post about it in detail separately, but what I’m posting about here is what I’ve done as part of the technology behind it. I’m using a simple XML schema to structure my content, and python to transform it into XHTML.

One feature I wanted was a nice table of references. The tutorial relies pretty heavily on both dead-tree texts, as well as online resources. I rigged up my transformation so that it would post an Amazon.com affiliate link (in the least obtrusive manner, of course) for the books I’ve referenced. So for each book there’s a nice picture of the cover, a link, and text explaining what part of the book I’m referencing, and why it’s important.

Problem was that external links and links to the plone.org documentation didn’t have any sort of image to represent them. I couldn’t work out anything I liked (made some icons, but they didn’t do it for me), so I thought it might be cool to use thumbnail screen captures of the pages I was referencing instead.

I know, this whole screencap/webthumb/snap shots thing is out of hand. Every link I mouse over everywhere seems to pop up some sort of DHTML fluff showing me a preview of the link I might be clicking on at some point. It’s especially annoying given that I like to check the urls of hyperlinks before I click them (silly me). I like to know where I’m going, but I don’t need to see where I’m going.

I bring up my distain for the snap shot trend only to emphasize that I’m not doing it the way I see it done everywhere. I suppose I could, but I’m not. The over use of snap shots also puts my fustration at finding a good solution to create the snap shots into perspective: it’s so popular, a google search for ‘website thumbnail’ comes up with a huge number of viable options. A cursory glance shows that none of them are packages you can run on your own, they’re all web services.

So, I decided to strike out on my own, and develop something from scratch.

Tool Chain

The rough steps to creating a screen capture are:

launch a browser
tell it to load a given url
take a screen shot
crop out window dressing and menus/controls
resize to a thumbnail size

This could be a manual process. This could work in MS Windows, or on Unix (or OS X for that matter). I was already developing my xslt transformation on an Ubuntu VM, and I can get a fair representation of what just about any web site looks like on any platform, thanks to Firefox’s cross-platform sweetness. This led me to try automating an X session via command line execution.

Since I was using Unix, ImageMagick also was a forgone conclusion to do the image editing (the mogrify command specifically). I then discovered a post someone made some time ago by chance, illustrating how ImageMagick can take screen shots.

I then found out that for a long time, FireFox has had more-or-less well documented command line interface options.

So with this in mind, I refined my process plan a bit:

start X
launch FireFox, specifying what url to load
call IM’s import command to take a screen shot of the firefox window on the right display
call IM’s mogrify command to crop out cruft.
call IM’s mogrify to resize to a thumbnail size
quit FireFox (since it will load additional calls into new tabs)
close X (if we’re all done… don’t bother if we’ll be taking more screen shots)

One problem with this is I have no way to know what windows are open or manipulate them. For example, on my default install of X, Firefox was loading in a 800×600 window. I wanted to take my screen shots at 1024×768, so Firefox would have to be resized. wmctrl to the rescue!

Wmctrl allows you to query and interact with the windows that your window manager is using. It gives you X Windows ID’s, and will let you close or resize windows by matching a word within their title. Good stuff.

I can get away with starting X running firefox at the same time as it’s sole executed application by specifying the full path to firefox as an argument to xinit.

$ xinit /usr/bin/firefox &

But this is problematic because it doesn’t run a window manager, and so wmctrl doesn’t work, and killing the X session without manually quitting firefox makes Firefox ask “Do you want to restore your session” the next time it runs (bad when you’re not there to click “Start a New Session”). That’s not acceptable for a situation like mine.

This meant I needed a window manager. I started with icewm but didn’t care for it, so I fell back to my personal favorite when I’m in X, blackbox. I like it for this task especially because it’s lightweight, and doesn’t put any widgets on the desktop that get in the way.

So now the process looks like this (with the actual commands)

start x:
```
$ xinit /usr/bin/blackbox &
```

launch FireFox, specifying what url to load:

$ firefox http://www.plone.org/documentation &

Resize firefox:
```
$ wmctrl -r firefox -e 0,0,0,1024,768
```

call IM’s import command to take a screen shot:

$ import -display localhost:0.0 -window root screencap.jpg

(Properly) close Firefox:
```
$ wmctrl -c firefox
```
call IM’s mogrify command to crop out cruft:
```
$ mogrify -crop 1006x648+0+95 screencap.jpg
```
call IM’s mogrify to resize to a thumbnail size:
```
$ mogrify -resize 100 screencap.jpg
```
close X:
I never figured out how to do this short of grepping through the output of ps

This works, more or less, in a manual way.

One caveat: you can’t do this from a remote terminal (like an SSH session) unless you change the way X is configured. I found a journal entry that pointed me in the right direction. You need to set allowed_users to ‘anybody’ in your XWrapper.config file. Since I was on Ubuntu, I tried using dpkg to reconfigure X as the journal entry suggested. This worked for me (it brings up a UI that asks a couple of questions including a question about allowed users):

 $ sudo dpkg-reconfigure x11-common

Getting Down to it (Coding, that is)

Now that you see where my mind was when I started this endeavor, you can understand the next steps, and the ultimate python code that I wrote.

My initial instinct was to try a shell script. This process came down to, after all, a list of shell commands. But as I started to write a shell script, things got messy and complex in a hurry, and the matter of getting X to close cleanly was problematic.

In addition, I wanted to integrate this more directly into my xlst transformation script, so Python became the obvious answer (as it tends to)

I utilized the newish subprocess module to handle executing the various commands. I wrapped it all in a class so I could easily share information (like what display to point at) across methods. I wrote methods to parse wmctrl’s window list output, and refined the process a bit so it would grab a specific window, instead of the root, or the whole X desktop (so I just got the browser and kept the cropped bits to a minimum).

I wrote unit tests for most of the functionality, so I’m confident that if you’re setup is like mine, you should have no trouble using the code.

Some features that go beyond the shell commands:

Can create a full-sized screen shot along with the thumbnail
Handles creating unique names for the files (does a hex md5 hash of the url)
Adds in wait time for the page to load
You can change WMs easily

It definitely is more flexible than it needs to be, and the code has a lot of potential:

You could set up a special profile just for taking captures (maybe run a special profile in a different language).
You could use it to take a screen capture when a Selenium test fails.
It could be adapted for any application, not just FireFox.
It’s designed so you can point it at any X server, not just localhost:0.0
- This means you could do a multi-threaded batch generation by starting the X server on different display numbers and rotating the work between them

So the end result is a nice module that will generate screen captures and thumbnails of web sites.

I’ve uploaded the code to my google code repo. The source is GPL right now, let me know if you want to use it under different terms.

Check it out

I appreciate all feedback/comments/enhancements/etc. Fire away!

XSLT Integration

Here’s how I integrated it into my XSLT:

Python

I opted to defer generation of the thumbnails to after the XSLT is all processed. It’s not as elegant as I’d like, but it works

...
from webthumb import XScreenCap

xcap = XScreenCap()
urls = set()

def linkwebthumb(context, url):
    """
    Return a URL that will represent a thumbnail screenshot of the URL contained in url

    Adds the url to the list of urls that need to be processed into screen shots
    """

    urls.add(url)

    return xcap.imagepath(url)

libxslt.registerExtModuleFunction('website-thumbnail', 'http://namespaces.joshjohnson.noresolve/util', linkwebthumb)
...
xcap.xinit()

for url in urls:
    xcap.makewebthumb(url)

xcap.killx()

This obviously leaves out the meat of the xslt processing stuff. Stay tuned, I plan to post about that in detail soon.

XSLT

I then can call the website-thumbnail function from within my XSLT template (the ‘util’ namespace is defined in the opening <xsl:stylesheet> tag, not shown):

<!-- snip -->
  <xsl:template match="ref">
    <div class="reference">
    <xsl:choose>
      <xsl:when test="@type='external-site'">
            <h1>External website, <a><xsl:attribute name="href"><xsl:value-of select="@href" /></xsl:attribute><xsl:value-of select="@href" /></a></h1>
            <div class="refimage">
                <a><xsl:attribute name="href"><xsl:value-of select="@href" /></xsl:attribute>
                <img border="0">
                   <xsl:attribute name="src"><xsl:value-of select="util:website-thumbnail(string(@href))" /></xsl:attribute>
                   <xsl:attribute name="alt">Screen Capture of <xsl:value-of select="@href" /></xsl:attribute>
                </img>
                </a>
                <br />
            </div>
            <div class="reftext" style="height:55px">
                <xsl:apply-templates/>
            </div>
            <br />
        </xsl:when>
     </xsl:choose>
     </div>
  </xsl:template>
<!-- snip -->

Again, there’s more to this than just the use of the thumbnail code… more on the ins and outs of xslt and libxslt when I post about it later

Potential Problems

There has to be a simpler way to do this
This should be fairly straight unix command line stuff, and should port well. In spite of that I haven’t tested this module on any other platform besides Ubuntu. I think the version I’m running is 7.10, the server version (no desktop environment included). I installed X and all of the other applications directly from apt.The first thing you should do once you’ve set up the components I listed earlier is run the unit tests. You can do this by running the module directly:
```
$ python __init__.py
```
This does not work on MS Windows (although I suppose you could point the code at some sort of X server on a MS Windows host).
I currently have no way of knowing when FireFox is finished loading a page, so I sleep after firefox is spawned (20 seconds at the moment, can be configured to be less). This makes generating thumbnails or running the unit tests take a lot longer than it could.
This is pure python 2.5 code. It might run in a late 2.4, but that’s untested.

Andi Zeidler: what a git!

By noreply@blogger.com (Andreas Zeidler) from Planet Plone. Published on Jan 09, 2009.

so here's the real reason i started it — nothing too exciting, but after a hunch of a discussion it simply had to go somewhere... :)

since i just figured the below out for the second time (after forgetting what the suitable git commands were since the first time a few months ago) i thought i might as well write it down. perhaps it'll come in handy at some point... :)

imagine you're offline, in a train or plane or cafe, and feel like getting some work done. you're starting to make changes and quickly realize you'd rather split things into several commits than just a single big one. however, you're working against a subversion repository and have — since you're offline — no way to commit things back right away or (conveniently) keep the patches separate. well, except perhaps for copying the whole directory for every single one and later merge/commit them one by one. not really worth the trouble... but git to the rescue!

even without a previously cloned svn repos it's quite easy to locally commit away and later replay your changes. here's a quick step-by-step howto:

initialize an empty git repos, propbably best done in the top dir of your working tree:

$ git init

add the current state to it (you might have to be more explicit here):

$ git add *
$ git commit -m 'import'

do your work, i.e. change things, locally commit to git:

$ vi ... # or emacs if you must ;)
$ git commit -a

being offline you leave it at that. once you're back online you wanna transfer those changes to svn, or, iow, apply them to a cloned git repository:

format/export the patches you've made (the rev specifier ":/import.." translates to "between a commit starting with 'import' and head) to separate files:
```
$ git format-patch :/import..
```
this will output numbered files, one file per patch, like:
```
0001-fix-1.patch
0002-fix-2.patch
...
```
remove your temporary git repos (or move it out of the way):

$ rm -rf .git

if you haven't done so already, set up the cloned repos (extra options might be required here), which allows you to commit back to svn:

$ git svn clone svn://svn-url

re-apply the patches:

$ git am 00*.patch

and finally commit back to svn:

$ git svn dcommit

Zea Partners: PloneGov in Italy: already reaping in 2009 what we sow in 2008

From Planet Plone. Published on Jan 09, 2009.

ANCITEL, the institutional IT network and service provider for more than 7000 Italian Communes, expressed its interest in evaluating the implications of getting involved in the dissemination in Italy of CommunesPlone - presently being ported in an Italian language, Italian accessibility regulations-compliant version. Even though preliminary, this opening to an in-depth examination of CommunesPlone potential seems promising, as long as ANCITEL, under the direct control of ANCI, the association of more than 7000 of Italian Communes, serves 90% of the Italian population.

Tarek Ziade: Distutils : improved .pypirc for Python 2.7 and 3.1

From Planet Plone. Published on Jan 09, 2009.

When you launch such a command:

$ python setup.py register sdist upload

There’s no way to give to Distutils your PyPI password in the prompt, so you distribution is uploaded to the server. You have to store your password in the .pypirc file:

    [distutils]
    index-servers =
        pypi

    [pypi]
    username: <username>
    password: <password>

The password is stored in clear text, so it can be used by Distutils to authenticate. This is rather unsecure, since anyone who has a read access to your home can get your password.

I have detected this problem this summer while listing the possible enhancements in Distutils. Nathan Van Gheem sent me a mail a month ago to ask for that same feature in collective.dist; which is a port of the latest Distutils features into Python 2.4 so Zope can use them. So before having it into collective.dist, the first step was to introduce it into Python itself.

The idea is to be able to remove from .pypirc the password so it’s asked at the prompt. Nothing fancy here : the Distribution object that is created before you launch any command is the place where you can share a context between commands.

So when you launch:

$ python setup.py register sdist upload

Here’s what is happening:

register looks into .pypirc, if no password is found, it asks it to the user using getpass
register use it then store it in the Distribution instance
upload look into the Distribution instance to see if the password was stored, and use it

This is now available in Python 2.7 and 3.1, and heavily tested.

I’d like to go further and to think about a ssh-agent like system, so there’s no need to enter the pasword everytime you work with PyPI in the same session.

Does anyone knows what would be the way to do it properly ? I think a ssh-agent like mechanism in Python’s getpass would be a great feature itself.

Brian Gershon: Finding Energy in the Mix of Art and Physical Computing

From Planet Plone. Published on Jan 09, 2009.

Santa brought me an Arduino this year - an open-hardware and open-software platform for connecting computers to the physical world — used by artists, designers, geeks, entrepreneurs who often find interesting things to create.

Now I’m finding renewal in a mix of art, physical computing, and the new concepts and ideas that come along with that.

What would you do with a platform where you can buy interesting off-the-shelf components (such as GPS, wired/wireless Internet connectivity, mini-cameras, color/light sensors, accelerometers) that you could put together then control via a small $35 micro-controller, or easily connect to your computer as input or output?

The possibilities are endless. Try searching for “physical computing” or “arduino” on YouTube.com for some ideas, or see Arduino Playground.

Creating gizmos that interact with the physical world make keyboards and computer screens pretty darn boring.

Personal note: Renewal is always very energizing. In regard to my software engineering interests, when I discovered Open Source in 2000, I learned everything I could about Linux and Open Source software, gave talks, ran Linux as my main desktop for many years. When I discovered Zope and Plone and Python in 2002, I helped fuel a local Plone community, and based my whole business on Plone (RagingWeb.com and now at WebCollective.coop) and never looked back. More recently I continue to find interesting projects in Plone and Django, while playing with Google App Engine, the Apple iPhone and the myriad of social applications that keep popping up.

What’s happening with Physical Computing in Seattle?

I missed an Arduino class in November, but discovered dorkbot seattle and attended my first meeting last night at 911media.org. I found a vibrant every-seat-taken mini-auditorium full of people ready to hear the night’s line-up (see photo above).

Here was the [paraphrased] lineup:

First, all three presenters are established artists with interesting projects. My brief takeaways don’t do justice to their work and knowledge. Please check out the links to their blogs for many cool projects and exhibits.

1. “Josh Kopel: “Out of Control” a quick review of the micro-controller and DIY electronics explosion that was 2008. 2008 might well be called the year of Arduino, as the little micro-controller from Italy invaded the DIY scene and showed up just about everywhere. Beyond just the Arduino, 2008 also saw a vast increase of interest in micro-controllers and unique interfaces for use in the arts.”

Some takeaways: I hadn’t realized Arduino was open hardware and all the variations that have arisen from that, such as the LilyPad Arduino that is a tiny wearable computer. Josh was mentioning that the mix of an open, inexpensive, and easy to leverage platforms (Arduino is just one of many platforms out there) plus the fact that you can find and buy components in sizes of 1 (versus years ago when you had to buy large quantities of parts) has brought this technology to the masses. Try searching for Arduino in Google Trends. One project where the husband hooked up a home-made gizmo to his wife that measured each time his unborn baby kicked with a “I kicked Mommy at 5:21pm” Twitter message got a pretty good laugh from the audience.

2. “Tina Aufiero: Computers, wireless cameras, electronics, and swans. Tina will talk about using computers, a wireless camera, and some electronics to marry the abstract concepts and representational forms in her works, which includes “project_swancam”. We know Tina as the Education Director at 911 Media Arts Center.”

Some takeaways: Swans are definitely interesting birds! Tina demonstrated a mix of her art, growing knowledge and experimentation with technology such as video manipulation and wireless camera, and her love for swans - which she has made into many interesting exhibits, and used to support her activism.

3. “Hugo Solis Garcia: Juum, a framework for multimedia production and composition. In his talk, Hugo will talk about Juum, a framework for multimedia production and composition that he has been developing during the last year. The tool has evolved because of the artistic requirements and the art pieces have been influenced by the program.”

Some takeaways: Hugo was able to augment his talents as a musician by creating new composition techniques using visual programming tools and home-made hardware. Too difficult to summarize, but my favorite piece was Tell-Tale Piano, which was a chair on top of a box that contained a used piano within. People could sit in the chair and experience dramatic music being created below their feet electronically via the piano which followed the theme of Edgar Allen Poe’s “Tell Tale Heart”.

What’s Next?

Josh Kopel will likely be teaching another class in March 2009
This year’s “People Doing Strange Things With Electricity” event is in June 2009, and is a showcase of projects by local artists and hobbyists. See dorkbot seattle archive for previous events and projects.

I’ve started my first Arduino project, now with additional inspiration from last night’s meeting, which I plan to blog about as the pieces come together…

Brian Gershon: Taming Twitter and RSS in 2009

From Planet Plone. Published on Jan 09, 2009.

As I gleam more information through blogs and microblogs there comes a time when the fun wears off and overload sets in.

In 2009, I’ve decided to tame overload and reinstate fun with some simple rules:

For Twitter (and other microblogging services):

Follow only folks that have a reasonable number of posts per day. Chronic Twitters (some individuals, but often sources like large blog sites or newspapers) force me to weed through a lot of cruft to come to the juicy information I can use. No one has infinitely interesting things happening all day long.
Twitter is not email - I find back-and-forth conversation via public twitter replies to be tedious unless one puts a bit of context in their reply. If the reply is interesting in itself, I’ll spend the effort to flip to the initial Tweet and try to see what was initially said.
For chronic Twitters that still do have some interesting morsels, I often stop following them on Twitter, but subscribe to their blog RSS and follow lower traffic there — RSS is much easier to skim through than Twitter. Garden hose instead of fire hose.
Don’t blindly follow! (good advice in many situations). When someone follows me, I check out their profile, recent Tweets, and number of Tweets per day before jumping in. If a reasonable number of posts are interesting, and they’re not Tweeting every moment of their lives, I will follow them too.
Keep it interesting! Sure, not every tweet someone makes is interesting, but many should be. Try out folks, but don’t be afraid to jump off without guilt. I’m personally attracted to Tweets pointing me to resources, interesting sites, or interesting happenings — in other words, I rely on my social graph to provide interesting content, not noise. I keep this in mind when posting Tweets for others.

For RSS

Cut out large noisy RSS feeds even if occasionally interesting. Feeds that produce too much traffic (albeit this traffic can safely be higher than microblogging since it’s easier to skim) even if a few morsels are interesting should be tossed because they prevent you from reading the really interesting ones.

We each have a limited amount of attention we can give - these simple rules will keep these services interesting and useful.

What other techniques do people use to handle the growing amount of information coming at them through microblogging (e.g. Twitter, Facebook), location-aware microblogging (e.g. BrightKite) and good old fashion blogging (via RSS)?

Eric Steele: Help me get to Baarn!

From Planet Plone. Published on Jan 09, 2009.

A shameful plea for financial support before I attempt the trip to the Baarn UI sprint.

John DeRosa: QA Lead & Release Manager job at Fisher Communications

From Planet Plone. Published on Jan 08, 2009.

My team has an opening for a QA Lead & Release Manager, for our Plone project. Here’s an excerpt from the full job description:

Location: Seattle, WA
Reports to: Director, Web Development

Fisher Interactive Network is a new division within Fisher Communications, and we need your help in changing the face of web news and information delivery!

This position is a founding member of FIN’s web development team. We’re using open-source technology to improve our sites’ sophistication and relevancy, and create new kinds of news and content delivery. We’ll need you to institute enlightened QA and code release practices. And help build this team’s culture.

The responsibilities will be to lead the QA effort, and own the release procedures used for build propagation. We’re seeking someone with experience in QA, but not necessarily in release management, because the latter can easily learned. We’re looking for experience in open source testing frameworks for web applications, and in Python, because it anchors our technology stack.

SPECIFIC DUTIES:
(Included but not limited to)

Responsibility for all Quality Assurance, and our test strategy’s overall integrity. This includes developing and overseeing our software test plans and validation procedures

Drive automated testing within the team. This includes selecting and managing automated test framework(s)

Be the primary liaison to the Operations Manager, and jointly manage the QA-Production boundary

Create and maintain functional tests; mostly automated, but also some manual testing. Review the test results for code coverage and regressions, and recommend corrective action

QUALIFICATIONS:

At least five years experience in software QA, and a strong appreciation and understanding of effective QA processes

xperience with open-source environments and tools, especially automated testing frameworks and technologies

At least three years experience with Linux and OS X. At least three years Python experience, or four years with another scripting language coupled with a strong willingness to learn Python

A healthy engagement with the industry and your trade. E.g., staying current with evolving and emerging technologies

A healthy respect for agile development processes, continuous integration, QA, and release procedures

Contact me if you’re interested. My e-mail address is john @ this site’s domain.

Tagged: jobs, plone

Ross Patterson: Plone 4 Framework Tream - Why I'm excited to have been selected

From Planet Plone. Published on Jan 08, 2009.

The more I think about it the more excited I am to be a part of the Plone 4 Framework Team (FWT).

I think it's fair to say that Plone is a very successful open source project. On that point alone, its an honor to serve a role in the continued success of the project. More than that, however, Plone has been successful for some time now. That success lies not just in the technology, but in the community as well, or if you prefer, the ecosystem.

What we have, then, is success that carries with it a history and a community that can't be abandoned without destroying that very success. That history and community also bring challenges with it. I myself find that my enjoyment of developing with Plone has kinda plateaued largely because I continue to have to deal with the code that is the legacy of that history.

The funny thing is that I don't find myself motivated as a crusader against that history wanting to rip it out wholesale. While this is a no-brainer in terms of the direction Plone development needs to take, I'm personally surprised by my motivations. I'm no longer so purely motivated as a developer. I'm genuinely excited to be a part of figuring out how to make Plone more fun and powerful for the whole community, users, themers, integrators, and developers alike.

How do we ditch old code without alienating large portions of the community when those portions of the community depend on their familiarity with the old code? How do we get developers excited about preserving continuity when we tend to prefer moving on? How do we make documentation sexy enough to attract and retain rock stars? How can we make preserving and improving performance as prestigious as adding new features?

I know I've changed because I can't imagine a more exciting set of questions to tackle. So yeah, I'm stoked to be a part of the FWT as we tackle exactly these issues in earnest. :)

Ross Patterson: Bristol Performance Sprint Post-Mortem - Functional benchmarking plus buildbot

From Planet Plone. Published on Jan 08, 2009.

I'll start with apologies for the tardiness of this post. Predictably, things got crazy as soon as I landed back home and between catchup and holidays, it's been tough. Thanks to Helge Tesdal for shaming me into posting finally. Fortunately, I had so much more fun at the sprint than over my holidays, the memory is still pretty fresh. :)

In fact, I couldn't put it down. Despite running on only a few hours sleep, a massively overloaded brain, and AirCanada's genuinely respectable selection of on-demand movies, I kept working on the buildbot integration. But I'm getting ahead of myself.

Since my last post on the performance sprint, Andrew continued to alternate between poking at the write concurrency issues and doing functional benchmark comparisons for some of the work being done at the sprint to measure impact. I really want to resume working with Andrew on the write concurrency issue. In particular I want to document what of the various performance optimizations, experimental or otherwise, have any significant impact on the performance. I had a lot of fun working with Andrew so maybe we can do some remote sprinting.

Meanwhile, I know Tom was working on the documentation in the buildout and refining the "candidate" story. The "candidate" stuff is a buildout configuration file that is intended to make it easy for developers to do comparison benchmarks to measure the impact their work has on the baseline Plone performance. I'm very excited about this work as a part of making functional benchmarking accessible and it's definitely something we'll want to take advantage of as we poke at the write concurrency issues.

For my part, I further refined the funkload and zope.testing integration. I also added a zc.recipe.testrunner clone to support adding the funkload test runner to a buildout. My real focus on the last day and on the flight home, however, was trying to work towards buildbot integration. I started by adding a build-diffs console script that uses "fl-build-report --diff" to generates differential reports comparing the most recent benchmark report against the previous report and against any available reports from a day, a week, a month and a year ago. The goal is to use this script in a buildbot setup, then to check the diffs generated to raise an error or a warning when performance appears to be negatively impacted by a change. Buildbot could then also be a way to access the longer term (day, week, month, year) diffs for a more long-term view of performance changes.

This next step is the actual buildbot integration. All the funkload support is there and the buildout works as needed. Getting buildbot to detect status from the diffs and to provide links to the diff reports will require some support from a buildbot step. I began researching buildbot steps on the flights home, but haven't started work yet. Matt has a server ready and waiting when we finally do have a working buildbot setup so I'd really like to get this done.

Hopefully it won't be as long until I get to poke at the write concurrency issue and finishing the buildbot integration as it was until this post. :)

Donna Snow: snowwrite

From Planet Plone. Published on Jan 08, 2009.

Recognizing the need for training in customizing the look & feel of Plone, C Squared (C2E) will start hosting quarterly training sessions focused on the “art of theming”. Our first 3 day session is scheduled for March 18 - March 20, 2009 and will focus on creating a Plone 3 theme product.

Trainees will be able to convert a photoshop file to an installable Plone 3 theme product. Training will include comprehensive css training (with more focus on Plone specific css), making sense of viewlets and portlets, adding your own css and javascript files, understanding generic setup profiles (making your changes in the zmi and exporting) and best practices for theming Plone sites.

Knowledge of Python is not necessary but basic knowledge of *nix or windows command line and comfort with working on the filesystem is suggested.

Please register for the course here

C2E Training offers a variety of Plone specific training sessions including sessions for content managers, integrators and designers. If you are in need of training for your organization please feel free to contact us at (408)866-1300

Sections

See also...

Plone.org: Announcing Usuarios Plone Mailing List

Jorgen Modin: Plone login portlet and the personal bar could be the same thing

Gerry J Kirk: The perfect first job for helping out the Plone community

Become the Planet Plone zoo keeper

But wait, there’s more

How do I sign up?

How can I add my blog to Planet Plone?

ifPeople: Plone makes Econtent 100 List for 2008

Josh Johnson: What have I done? (website screen captures/thumbnails in python and a lot of shell commands)

Introduction

Tool Chain

Getting Down to it (Coding, that is)

XSLT Integration

Python

XSLT

Potential Problems

Andi Zeidler: what a git!

Zea Partners: PloneGov in Italy: already reaping in 2009 what we sow in 2008

Tarek Ziade: Distutils : improved .pypirc for Python 2.7 and 3.1

Brian Gershon: Finding Energy in the Mix of Art and Physical Computing

Brian Gershon: Taming Twitter and RSS in 2009

Eric Steele: Help me get to Baarn!

John DeRosa: QA Lead & Release Manager job at Fisher Communications

Ross Patterson: Plone 4 Framework Tream - Why I'm excited to have been selected

Ross Patterson: Bristol Performance Sprint Post-Mortem - Functional benchmarking plus buildbot

Donna Snow: snowwrite

Document Actions