Although the presentation is in German, I think it might help to better understand the syntax by seeing a practical example.

The whole presentation with all the files needed to generate it can be downloaded in a ZIP file.

• Redefined functions
• Shadowed variables
• Unused and undefined names
• Unused or missing imports
• Variables referenced before assignment

Installation

Because of a few noteable fixes over the latest stable release (0.2.1) from October 2005, I’m going to describe how to install the latest trunk from the Subversion repository.

The first thing we’re going to do is a checkout in a directory called pyflakes:

svn co http://divmod.org/svn/Divmod/trunk/Pyflakes pyflakes

After that, we create the symbolic links to the Python site-packages directory and a binary path (here: /usr/local/bin).

ln -s `pwd`/pyflakes/pyflakes SITE-PACKAGES-DIR/pyflakes
ln -s `pwd`/bin/pyflakes /usr/local/bin

The Python site-packages directory can be found by invoking the following command:

python -c "from distutils.sysconfig import get_python_lib; print get_python_lib()"

TextMate integration

The Python bundle for TextMate includes the PyCheckMate script which has support for PyChecker, PyLint and PyFlakes. The bundle is installed in a default TextMate installation.

PyCheckMate automatically checks for and chooses one of the supported programs mentioned above. To change this, we can modify the TM_PYCHECKER variable in ~/.bash_profile:

export TM_PYCHECKER=pylint

The supported values are:

• builtin (also used when no other checker is installed, only performs a syntax-check)
• pychecker
• pylint
• pyflakes

Setting the variable is not needed when only PyFlakes is installed.

To perform the check in TextMate, go to Bundles -> Python -> Validate Syntax (PyCheckMate) or press the shortcut Ctrl-Shift-V.

The initial idea came from Zed Shaw who wrote a similar script for his RuPy 2008 presentation and published it on his blog.

Why?

I’ve done presentations with LaTeX Beamer in the past, but always had a hard time remembering the LaTeX syntax for things like adding a table of contents, displaying the current frame number in the footer or adding an itemized list which highlights the current element.

The only thing I always remembered was the basic structure of LaTeX Beamer presentations (sections, subsections, frames) — and that’s where YAML, with its hierarchical structure, comes into play. You don’t have to remember the LaTeX commands for creating a presentation, just the basic structure.

Features

The purpose of this script is to generate a presentation which mainly includes (nested) itemized lists. It is also possible to make a frame with an image in it and a frame which includes highlighted source code (with help from Idiopidae).

The YAML hierarchy is perfect for the features mentioned above, but not for most of the other commands LaTeX Beamer has to offer. For example, trying to create columns in a frame would be hard to realize and only complicate the YAML syntax.

Syntax

In order to generate a presentation, the script requires the YAML file to have the following syntax:

- section:
  - subsection:
    - frame:
      - item
      - item
      - item

(The dashes are necessary to parse an item into a List instead of a Dictionary in Python. Dictionaries have no concept of order among elements — the presentation would be completely unordered.)

The items in each frame can also be nested:

- section:
  - subsection:
    - frame:
      - item
      - item:
        - item
        - item
      - item

Note that LaTeX Beamer limits the maximum depth of nested items to 3.

Images

To create a frame with an image in it, the title needs to start with the “image” keyword and define the image path after it. The following example will create a frame and include the “foobar.png” image.

- section:
  - subsection:
    - image foobar.png:
    - frame:
      - item
      - item
      - item

Images are automatically shrunk to the size of the frame.

Syntax Highlighting

yml2tex will create a placeholder/marker for Idiopidae whenever it finds a frame which starts with the “include” keyword and is followed by the path of the file which should be included.

- section:
  - subsection:
    - include foobar.c:
    - frame:
      - item
      - item
      - item

Remember to run your generated LaTeX file through Idiopidae to actually include and highlight the source code:

idio out.tex > out_idio.tex

Generating the presentation

The first parameter needs to be the path to the YAML file. The output will be printed to stdout.

./yml2tex.py input.yml > output.tex

After generating the LaTeX syntax, you can build the presentation by executing the pdflatex command:

pdflatex output.tex

Default Style & Added Elements

The default style was taken from Ki-Joo Kim’s Beamer v3.0 Guide. The script will also:

• Set UTF-8 as the default encoding.
• Highlight the current item in a itemized list.
• Add a title slide.
• Add a TOC after the title slide.
• Add a TOC before each section with the current section highlighted.
• Display the current and total frame count at the bottom of each slide.
• Include the necessary packages and commands for Pygments “colorful” style.

You can download a demonstration pdf of a generated presentation (and/or download the source code).

One thing that has always bothered me with the old layout was its boring, black & white only, look. I wanted a colorful but still minimal and clean layout and think that the new design does exactly that.

It’s the first time I’ve played around with grid-based layouts. After reading a few articles about it and looking at various CSS frameworks (like YUI or 960) I’ve settled with Blueprint and am very impressed by it so far. Beside setting the layout grid, it also applies typographic enhancements such as a vertical baseline grid (as described by Wilson Miner on ALA).

As for new features, the most noticeable is probably the bookmarks sidebar which pulls its content from my del.icio.us account. Finding similar content was pretty hard on the old site since it didn’t display any tags or categories. That has changed, tags are now displayed at the bottom of each post and linked to a tag-based archive.

Unfortunately, the website is still based on Wordpress and hosted at DreamHost. It’s okay for now, but as soon as my DreamHost account expires I’m going to switch to a Django-based solution and deploy it on a better web host.

I installed GnuPG through MacPorts. However, with MacGPG there’s a simpler but also more outdated solution available. You can also give a more recent MacGPG test-release a try.

GnuPG

The GnuPG installation via MacPorts is pretty straightforward:

sudo port install gnupg2

Pinentry

A problem with the MacPorts bundled pinentry is causing it not to display any password dialog when encrypting an email. The solution is to use a patched version which can be downloaded here.

After unzipping, the pinentry-mac application needs to be moved or copied to the /Applications directory:

mv pinentry-mac.app /Applications/

The gpg-agent configuration file (~/.gnupg/gpg-agent.conf) must to be modified in order to use the new pinentry-mac:

pinentry-program /Applications/pinentry-mac.app/Contents/MacOS/pinentry-mac

To reload the configuration, gpg-agent needs to be restarted:

killall gpg-agent
gpg-agent --daemon

GPGMail

The latest GPGMail plugin beta for Leopard’s Mail.app can be found here.

To make use of custom bundles in Mail.app, it needs to be enabled first:

defaults write com.apple.mail EnableBundles -bool yes
defaults write com.apple.mail BundleCompatibilityVersion -int 3

A “Bundles” directory must be created in ~/Library/Mail/ and the .mailbundle file from the mounted GPGMail dmg needs to be copied there:

mkdir ~/Library/Mail/Bundles
cp -r /Volumes/GPGMail_d53_Leopard/GPGMail.mailbundle ~/Library/Mail/Bundles/

Upon a restart of Mail.app, a notification should display a small warning about missing keys. The GPG Howto from the ubuntu documentation describes the process of generating keys pretty well.

That’s it, i hope this guide was helpful to some people. You can find my current public key here. or download it from a keyserver like the MIT’s Public Key Server (0×83ABBBE7).

If you don’t want to follow the whole instruction, be sure to check out the Bash script, which installs LaTeX Beamer for you, at the end of this post.

Installation

First we need to download LaTeX Beamer and it’s required dependencies (xcolor and pgf). The files can be downloaded on the corresponding website at SourceForge or via these direct links:

• latex-beamer
• xcolor
• pgf

Upon completion of the download the files need to be extracted:

tar xvzf latex-beamer-3.07.tar.gz
tar xzvf xcolor-2.00.tar.gz
tar xvzf pgf-1.01.tar.gz

The TeX directory structure has a specific hierarchy (the TEXMF tree) and various locations where it looks for its files. The default TEXMF tree on a MacPorts TeX Live installation is located at /opt/local/share/texmf/.

To make use of the packages, we need to create the appropriate directories in the TEXMF tree, and place the previously extracted files there:

sudo mkdir -p /opt/local/share/texmf/tex/latex/{beamer,pgf,xcolor}

sudo mv latex-beamer-3.07/* /opt/local/share/texmf/tex/latex/beamer/
sudo mv pgf-1.01/* /opt/local/share/texmf/tex/latex/pgf/
sudo mv xcolor/* /opt/local/share/texmf/tex/latex/xcolor/

TeX does not recognize these new files right away since it uses a cache (the ls-R database) for efficiency reasons. The following command rebuilds the ls-R database:

sudo texhash

Testing

We can copy&paste the example from the LaTeX Beamer website into a newly created file and compile it in order to test the installation:

pdflatex filename.tex

This should, among various other file formats, create the presentation in the pdf format (filename.pdf).

Bash script

Following a installation instruction step-by-step can be a very time-consuming task. But since I’m a huge fan of automating tasks, I wrote a small Bash script which basically performs all the steps mentioned above. (Note: You’ll need to have wget installed.)

Download the Bash script here

Don’t forget to make the file executeable:

chmod u+x latexbeamer_texlive.sh

That’s it. I hope the Bash script will be useful for some people.

For further information on the TeX system, I recommend reading Managing a one-person TeX system.

I just put the Book Recommendations section online, feel free to check it out. I’ll try to keep it up-do-date.

My current to read list consists of the following books:

• The Design of Everyday Things
• The 7 Habits of Highly Effective People
• The Mythical Man Month: Essays on Software Engineering
• Managing Humans: Biting and Humorous Tales of a Software Engineering Manager
• Ready, Fire, Aim: Zero to $100 Million in No Time Flat

Other book recommendations are always welcome.

Here’s a short summary of what services a bullet proof cookie should provide:

• Authentication
  Verify that the client has been authenticated within a certain time period.
• Confidentiality
  • Low-level
    Prevent any parties except the user and the server from reading the cookie data.
  • High-level
    Prevent any parties except the server from reading the cookie data.
• Integrity
  The server should be able to detect if a cookie has been modified.
• Anti-Replay
  Stolen cookies should be detected as invalid.

Confidentiality

In my opinion, high-level confidentiality is unnecessary. I think Marcus R. Breese describes this best in his blog:

“Specifically, my rule of thumb is that if you don’t want a client to know
the data, don’t send it to them.”

I totally agree with him and further think that cookies should be used for
authentication only, and that the data should be stored in the database.

Example: Wordpress

Wordpress 2.5 introduced a similar structure for its cookies as the one proposed in the research paper. In Wordpress 2.5 cookies have the following structure:

user name|expiration time|HMAC(user name|expiration time, k)
where k=HMAC(user name|expiration time, sk)
and sk=secret server key

Therefore a normal Wordpress cookie looks like this:

admin|1212093864|82436be3x303xaddd6fd31db338770a6

There are two points which are different from the originally proposed cookie protocol from Alex X. Liu.

The first one is that there’s no data attached to this cookie - it’s only used to authenticate the user. The second one is that there’s no SSL session key attached.

Removing the SSL session key was not a good (vulnerable to replay attacks) but necessary choice since most Wordpress installations run on non-SSL hosts.

Changes

This is the original protocol:

user name|expiration time|(data)k|HMAC(user name|expiration time|data|session key, k)
where k=HMAC(user name|expiration time, sk)
and sk=secret server key

I removed (data)k and session key, which changes the protocol to:

user name|expiration time|HMAC(user name|expiration time, k)
where k=HMAC(user name|expiration time, sk)
and sk=secret server key

The data field was removed because I couldn’t find a good two way encryption library for Python, and the session key was removed due to the lack of SSL.

The new structure is similar to the one used for the authentication in the backend of the recently released Wordpress 2.5.

Usage

To create a cookie in Django, use the set_cookie method of the response object:

cookie = myutils.generate(‘arthur’, 1210708139)

response = render_to_response(‘index.html’)
response.set_cookie(‘mycookie’, cookie)

return response

Of course there’s the ticket in Symfony’s Trac with the files attached to it, but the attached php class is the wrong one. In order to use it, you had to apply the attached patch manually (which I guess caused some confusion).

However, I ran the unit test for the improved sfDateValidator against Symfony 1.0.14, and it still works very well. So, here’s the new download link:

Download the improved sfDateValidator for Symfony 1.0

You might want to head over to the old post on Symfoniac for a quick usage example.

git-fetch && git-merge origin

The fetch gets the changes from the remote repository, but does not merge them with your local checkout yet. You can examine these changes using origin as the reference, and merge them into your master branch.

The git-fetch part is optional. You can pass . (current directory) to it and merge local branches.

git-pull . refactor
git-merge refactor

Both commands will do the same: merge the refactor branch.

Install with MacPorts:

sudo port install git-core +svn +bash_completion

Bash completion:

cp /opt/local/etc/bash_completion.d/git ~/.git-bash-completion.sh
echo "[ -f ~/.git-bash-completion.sh ] && . ~/.git-bash-completion.sh" >> ~/.bash_profile
. ~/.bash_profile

Global ignore file:

echo ".DS_Store" >> ~/.gitignore
git config --global core.excludesfile ~/.gitignore

SVN-like shortcuts for often used commands:

git config --global alias.st status
git config --global alias.ci commit
git config --global alias.co checkout
git config --global alias.br branch

Information about the author/commiter:

git config --global user.name "Your Name Comes Here"
git config --global user.email you@yourdomain.example.com

Colorized output:

git config --global color.branch auto
git config --global color.diff auto
git config --global color.interactive auto
git config --global color.status auto

TextMate as the default editor:

git config --global core.editor "mate -w"

Opendiff (FileMerge) to resolve merge conflicts:

git config --global merge.tool opendiff

Change the font in gitk: Open ~/.gitk and add:

set mainfont {Monaco 12}
set textfont {Monaco 12}
set uifont {Monaco 12}

While writing down the commands for further use, I noticed that there’s a faster way than cloning the official SVN repository by using an unofficial Git mirror. Later on, I wrote a small Bash script to automate the Django-from-Git installation, which you can download below.

Official SVN repository

First, clone the repository with:

git svn clone -s http://code.djangoproject.com/svn/django django

navigate to the django folder and run:

git gc

to cleanup unnecessary files and optimize the local repository. Finally, reset the master branch to point to trunk:

git reset --hard trunk

Git mirror

Instead of going thrugh the time-consuming task of cloning the official SVN repository, there’s an faster and easier way. Matthias Kestenholz was so kind to set up a Git mirror for Django, which is updated hourly.

Just use the git clone command, as with any other Git repository:

git clone git://spinlock.ch/pub/git/django/django.git django.git

Bash script

To save some time on the next “Django from Git” installation, I wrote a simple Bash script to automate this task.

The script will clone the unofficial Git mirror in a folder called django.git and create the necessary symbolic links to install Django: 

1. django folder to the python site-packages directory.
2. django-admin.py file to a directory on the system path (the script uses /usr/bin).

Download django-git-install

After the download, you need to make the script executable:

chmod u+x django-git-install.sh

The script expects the installation directory as the first parameter:

Usage: django-git-install.sh target-directory

For example, to install Django into /usr/lib/django.git, execute:

sudo ./django-git-install.sh /usr/lib

Listed below are the average scores of 6 XBench Memory Test runs.

Benchmark

Seagate Momentus: 41.47 MB/sec
Western Digital Scorpio: 55.51 MB/sec

Seagate Momentus: 38.66 MB/sec
Western Digital Scorpio: 51.31 MB/sec

Seagate Momentus: 17.46 MB/sec
Western Digital Scorpio: 13.59 MB/sec

Seagate Momentus: 38.87 MB/sec
Western Digital Scorpio: 53.82 MB/sec

Seagate Momentus: 0.72 MB/sec
Western Digital Scorpio: 1.88 MB/sec

Seagate Momentus: 20.81 MB/sec
Western Digital Scorpio: 33.89 MB/sec

Seagate Momentus: 0.47 MB/sec
Western Digital Scorpio: 0.50 MB/sec

Seagate Momentus: 16.87 MB/sec
Western Digital Scorpio: 20.65 MB/sec

Temperature/Noise

The temperature stayed the same, at 32°C. There was no noticeable increase in loudness with the new hard drive.

In the first moment I noticed that the WD Scorpio is vibrating a little more than the Seagate Momentus (the hard drive’s location is directly under the left hand). However, it became pretty normal after half-an-hour.

Conclusion

There was only one test (sequential uncached read with 4K blocks) where the WD Scorpio was slightly slower than the Seagate Momentus, but all the other tests show a massive improvement.

There were quite a few people told me that upgrading the MacBook’s default hard drive would definitely be worth it, but I never expected it to be so clear. All in all, I’m happy with the new hard drive.

The program was splitted into simultaneously held Ruby and Python talks. For example: while the “TDD in Rails” talk in room A, a “TDD in Python” talk was held in room B. Language-independent talks, like “Business Natural Languages”, were held in one room.

Talks

I missed half of Micheal Foord’s talk on “Programming the Browser with IronPython and Silverlight” due to my late arriving. However, the stuff which I saw gave me some nice insights into what IronPython and Silverlight are capable of.

Watching the adoption of Silverlight and development of Moonlight (Silverlight for linux) is quite interesting, especially since Microsoft made a deal to put Silverlight on the official Beijing Olympics website. 

The next talk by Zed Shaw about “Correlations and Conclusions” was really funny but also very informative. He benchmarked Mongrel against web.py and inserted the data into R. R seems like really nice tool for statistical data and once you get used to it’s weird syntax there are certainly a lot of things you can do with it.

What I didn’t know was that httperf is more superior to ab and used for serious stuff, while ab is mostly okay for quick’n'dirty benchmarks.

The presentation itself was done using latex-beamer and generated out of a YAML file - a quite interesting concept which Zed Shaw is going to describe further in his blog.

Jonathan Hartley, who works together with Micheal Foord at Resolver Systems, held a great talk about Test-driven development and shared his experiences over the past few years. A really interesting fact is the ratio of test code to product, which is 4:1 - meaning that there are four lines of test code for each line of product code.

Business Natural Languages (a Domain Specific Language for empowering subject matter experts) were presented by Jay Fields from ThoughtWorks. The whole point in a BNL is to allow the customer to change the applications behaviour without involving the developer. It’s definately worth a look for some bigger projects.

Bottom line

The organization was perfect and the choosen topics very interesting. The only negative thing was actually lunch, which was horrible (and not very warm).

However, it was a great conference which I can only highly recommend to everyone interested.