I was looking for random, useless facts on the Internet the other day and found one that said:

“Skepticisms is the longest word that alternates hands when typing.”

This turned out wrong. A friend convinced me to write an application to work it out, and I decided to make it do more…

The application uses the UNIX words file to scan for words. Granted, not all the words actually are real, but it is a good indication.

To cut to the chase, the longest words with one hand on the QWERTY keyboard layout are 12 letters long:

aftereffects, desegregated, desegregates, reverberated, reverberates, stewardesses

These are all left handed words. In fact, there are 57 longer words that can be typed than the longest right handed word. The longest right handed word is “polyphony” with 9 letters. I found this a bit unusual so I decided to graph it (below). With alternating key strokes, the longest words are:

authenticity, enchantment, entitlement, proficiency, shantytowns

These are 12 letters for authenticity and 11 for the rest.

Here are the graphs for QWERTY with left vs right vs alternating sides:

I recall that the Dvorak Simplified Keyboard was designed with alternating hand key strokes in mind. With alternating sides, the highest word count is 14–slightly more than QWERTY’s 12. These words are:

overemphasized, overemphasizes, unpremeditated, verisimilitude

Interestingly enough, the Dvorak layout has very few words that have multiple key presses on the same side of the keyboard. The left side is the most popular with the longest words, at 6 letters, being:

kookie, opaque, papaya, upkeep, yippee, yuppie

brr, nth

Here is the Dvorak graph:

The graphs are made with Google Charts API using the pygooglechart module. If there’s enough interest I’ll throw the code up on github.

In the past, people have hassled me to make it easier for them to install my applications and libraries on OS X. I’m not very skilled with OS X, and searching for how to do this task took some time. I’ve made a script that does this in a modular way for Python. Specifically, this article describes the process of making a Python module or extension installer for OS X, similar to the Python installer for Windows.

Read the rest of this entry »

I just released pygooglechart 0.2.1. It has several bug fixes and minor additions, but the major change is that it now supports QR codes. You can quite easily create a QR code with pygooglechart as you can see below.

from pygooglechart import QRChart

# Create a 125x125 QR code chart
chart = QRChart(125, 125)

# Add the text
chart.add_data('Hello, World!')

# "Level H" error correction with a 0 pixel margin
chart.set_ec('H', 0)

# Download
chart.download('qr-hello.png')

This will download a png from the URL:

http://chart.apis.google.com/chart?cht=qr&chs=125×125&chl=Hello%2C%20World%21&chld=H|0

The image downloaded looks like this:

QR codes are new to me. I’ve only seen a QR code on a bus stop advertisement once in Sydney but I’m sure more will pop up.

I wrote an application to generate a wireless (802.11) heat map based on signal strength. The reason for it was to find the best place/area (for my laptop) to be with the highest signal strength. Below is a screenshot of the application (with the ESSID and BSSID removed for security reasons).

This heat map has about 100 samples in it, which are shown as white dots. There is a balcony at the top of the image and the common office area on the right, which was drawn by hand (hence the waviness). As you can see it has pinpointed the location of the access point in the red area.

Read the rest of this entry »

Last week I quietly released pycallgraph 0.5.1 with some outstanding bugs fixed and preparation for it to be a Debian package.

Cython is an easy way to create Python extensions in “pseudo-Python” without having to deal with the verboseness of the Python API. It also does not rely on you knowing much of the C language. Cython is based on Pyrex which I have some experience with. This tutorial shows you how to convert a simple Python module to a Python extension.

Read the rest of this entry »

I decided to make a CAPTCHA plugin for Trac called TracRecaptchaPlugin, to stop spammers using the ticket system. There is an existing Trac plugin to fight spammers, but it still lets through many automated spammers.

The plugin uses the reCAPTCHA service and is serving me well so far. Here’s how it looks within the template:

This is my first publicly released Trac plugin so I’m unsure how it’ll perform out there, so feedback is welcome.

I released pygooglechart 0.2.0 this afternoon after several months of patches coming in to add features and fix bugs. The main addition to pygooglechart is automatic data scaling, which is turned on by default. You can also specify the scale range manually:

chart = SimpleLineChart(width, height, x_range=(0, 100), y_range=(0, 100))

Other features are the new API chart types and options. There are 3 new chart types: Map, Google-o-Meter and Radar. Here is an example of using the Map chart type:

import pygooglechart as gc

chart = gc.MapChart(440, 220)
chart.set_colours(('AAAAAA', '30A030', 'A0C030'))
chart.set_codes(['AU', 'US', 'CA', 'BR', 'NZ'])
chart.add_data([1, 0.5, 0.7, 0.3, 0.1])
chart.download('map.png')

Produces the URL:
http://chart.apis.google.com/chart?cht=t&chs=440×220&chd=s:9frSG&chco=AAAAAA,30A030,A0C030&chtm=world&chld=AUUSCABRNZ

And the image:

The Google-o-meter has a funny name. Here is an example of its usage:

import pygooglechart as gc

chart = gc.GoogleOMeterChart(440, 220, y_range=(0, 10))
chart.set_pie_labels(['Awesome'])
chart.add_data([8])
chart.download('gom.png')

It produces this URL:
http://chart.apis.google.com/chart?cht=gom&chs=440×220&chd=s:x&chl=Awesome

And the image:

Well, have fun. Please write a ticket for any bugs, patches or feature requests you have.

IPython is great for typing up quick tests. Unfortunately it is annoying when you have to import modules just to use it for one or two commands. autoimp is a Python module where it automatically imports modules when you refer to them. It works well with IPython simply by adding “import_all autoimp” somewhere in your “~/.ipython/ipythonrc” file.

I’ve got a large list of things to do, but decided to finally implement my new HTML/CSS theme to this blog. Tell me what you think or see any problems with it. I will use the same theme with the slowchop.com project sites.

Just a quick update. I have recently made some Python releases.

• PyGoogleChart 0.1.0 - Initial release of a Python wrapper for the Google Chart API.
• Python Call Graph 0.4.1 - Speed improvements for the visual call graph Python library.

I find readability very important when reading data. It saves time and energy. To me, Python’s pprint module is not easy to read in a lot of cases so I made my own. This is how pprint looks like at the moment:

BetterPrint is based on a lot of the source code, which looks about 10 years old. It makes more sense to me to have braces aligned by column rather than jammed together inline. BetterPrint also introduces colour to increase readability even more. As you can see from the following screen shot:

BetterPrint is compatible with Python’s pprint module, so you can simply “import betterprint” aliased as pprint like so:

try:
    import betterprint as pprint
except ImportError:
    import pprint

If you have setuptools installed simply run “easy_install betterprint”, or visit the web page for more details and installation instructions.

After promising myself to do it after many months, I’ve finally written a Greasemonkey script to reformat JSON output to be easily readable by a human. I may do cool things like syntax highlighting and expandable branches in the future, if the need and/or time arises.

I’ve just released pycallgraph 0.4.0. It has several major new features including a command line interface and measuring accumulative time per function.

The 0.4.0 pycallgraph CLI supports function filtering, timing filtering, maximum stack level and a few more settings. For example, to do a simple call graph on “myfile.py”:

pycallgraph-dot.py myfile.py mygraph.png

Here’s an example that doesn’t include the class Foo and outputs to a SVG file format:

pycallgraph-dot.py –exclude=”*.Foo.*” –image-format=svg myfile.py myfile.svg

Turns out far easier than modifying your source code to create a call graph.

Here’s one of the graphs from the source code examples colours.py:

As you can see it has green and orange gradients. One end of the gradient is green because of the number of calls is high and the other is orange because the function calls are taking the longest. All that with a function that looks like this:

def orange_green(calls, total_time):
    """Make a higher total time have an orange colour and a higher number
    of calls have a green colour using RGB.
    """
    return '#%02X%02X%02X' % (
        0x30 + total_time * 0xc0,
        0x30 + calls * 0xc0 + total_time * 0x70,
        0x30,
    )

I hope it’s useful to you!

I’ve made a small quick reference guide to SQLAlchemy if anyone is interested. I’ll update it as often as I have to look up something in the official documentation.

For the lack of updates, here is an update:

• Just released pycallgraph 0.3.1 which fixes a few bugs.
• This week hopefully releasing a pre-alpha of c80 which is an AJAX IRC client.
• Development of VirtuShare, a transparent peer-to-peer networking service, is still in progress.

I’ve redesigned the Trac project web sites. For example pyraknet and pycallgraph have the new layout. Feedback is welcome!

I have released pyraknet 0.1.4! For those who don’t know… it lets you easily apply multi-player networking to your python game pretty easily. Enjoy!

After the web server slashdotting I decided to install and set up lighttpd to replace Apache. Pages seem to load quicker now!

pycallgraph has been slashdotted.

I’ve temporarily disabled the vserver until Gerald can debug the problem.