Programming on Lorenzo Bolla

Python MRO surprises

Fri, 02 Dec 2022 00:00:00 +0000

Consider a script like this:

class A:
 def __init__(self):
 print('a')

class B:
 def __init__(self):
 print('b')

class C(A, B):
 def __init__(self):
 super().__init__()
 print('c')

C()

What will it output? If you are like me, you would answer, without much thought, that it prints:

a
c

To work it out you need to know about Python's MRO (Method Resolution Order): this article provides a clear explanation of how it works. In this case, we have:

gio in cronjob

Mon, 14 Dec 2020 00:00:00 +0000

gio provides a nice API to deal with VFS. I am using it to mount a NAS harddrive to use for backups.

The problem is that using it from cronjobs is not straightfoward. I got the following errors when trying to run gio info and gio mount from a cronjob:

gio: smb://internetbox-nas.local/philips%20ufd/: Operation not supported
gio: smb://internetbox-nas.local/philips%20ufd/: volume doesn’t implement mount

I didn't find the right answer in Google, so I am sharing it here in case someone else is affected.

Goodbye Linode, welcome AWS!

Fri, 11 Dec 2020 00:00:00 +0000

After many years of service, I decided to move away from Linode. Linode has been hosting this website and my backups flawlessly and gave me my first introduction to Cloud computing back when it wasn't so widespread.

Since then, many new players have joined the cloud computing space and few big players have come up on top. Amazon AWS is obviously one of them. I decided to go with them over Linode for a couple of reasons.

Impl specialization in Rust

Sat, 11 Apr 2020 00:00:00 +0000

Yesterday I learnt about a feature in Rust, currently only available in nightly: impl specialization.

I had to solve the problem highlighted in the following snippet:

use std::hash::Hash;

trait Foo {
 fn get_foo(&self) -> String;
}

impl<T: Hash> Foo for T {
 fn get_foo(&self) -> String {
 "foo for hash".to_string()
 }
}

impl Foo for String {
 fn get_foo(&self) -> String {
 "foo for string".to_string()
 }
}

fn main() {
 let bar: String = "bar".to_string();
 println!("{}", bar.get_foo());

 let baz: i32 = 1;
 println!("{}", baz.get_foo());
}

Compiling this code gives the below error:

Nice threads in Python

Sat, 01 Feb 2020 00:00:00 +0000

Python has two ways to execute code in parallel: processes and threads. Both have their strengths and weaknesses. In particular, threads are cheaper in terms of resources and are able to share memory, but besides the obvious pitfalls of multi-threaded programming, they suffer from some Python specific problems, notably:

Because of the GIL, only one Python's thread is actually running at any one time. So, very little parallelism is possible if the task is CPU bound. In fact, more often than not, it's more efficient to execute multiple tasks sequentially on a single thread (pinned to a single CPU), rather than spawning multiple threads and having the Python interpreter context switching too much and not being able to schedule the threads on all available CPUs.

Speeding up Oh-my-zsh

Sun, 20 May 2018 00:00:00 +0000

Today I read a very interesting article about speeding up Oh-my-zsh. So, I tried to profile my own startup times and I discovered that:

Zsh start time was about 500ms
Bash start time is less than 10ms
Zsh (without config) start time is less than 10ms

Most of startup time was spent loading 3 plugins that I regularly use:

emacs, which provides handy aliases to interact with Emacs daemon. I was surprised this plugin was slow because it just defines a bunch of aliases. It turns out that it was spending 50+ ms checking Emacs' version (by starting up Emacs every time). I sped it up considerably by instead checking emacsclient version. PR submitted.
kubectl, which provides aliases and completion for kubectl. It turns out that it was spending 200+ ms to generate the completion script using kubectl completion zsh every single time. I sped it up by caching the completion script, that is not subject to change very often. PR submitted.
virtualenvwrapper, which sources virtualenvwrapper.sh and little more. Virtualenvwrapper also supports a "lazy" version of its script, so I sped up startup times by preferring the "lazy" script to the "eager" one. PR submitted.

I hope the above 3 PRs will be approved and merged!

Edit Kubernetes secrets

Sun, 14 Jan 2018 00:00:00 +0000

Kubernetes secrets are difficult to edit using standard command line tools, like kubectl.

When doing kubectl edit secret my-secret you are presented with a base64-encoded blob that you have to first decode, in order to edit it and then re-encode before saving the file.

There are various ways to deal with it, but none is user-friendly, in my opinion. Therefore, I wrote kube-secret-editor: a simple Python script to decode and encode secret values on the flight before/after editing.

Kubectl outdated plugin

Thu, 04 Jan 2018 00:00:00 +0000

We use Kubernetes at work and I am mostly responsible for making it run smoothly. This means staying on top of new releases, libraries and tools that come out at a pace I've never experienced before, in any project.

To help with that, I wrote a kubectl plugin that finds outdated components in a Kubernetes cluster. The code can be found here.

It works like this.

First it goes through all deployments and daemonsets, collecting the images referenced in their containers.
For each container, search for a newer image tag in its repository. I currently support querying Docker Hub and Google Container Repository (you need gcloud for that).
Outputs which deployment or daemonset needs upgrading.

E.g. running it on a testing cluster I setup gives this output:

org-based lbolla.info

Thu, 04 Jan 2018 00:00:00 +0000

lbolla.info is now written in Org.

I use org-mode daily for all sorts of tasks:

TODO list
Keeping tracks of meetings, events, etc.
Note taking
Presentations

It was annoying to have to switch to another markdown language for blogging. So, I looked into org-publish for a simple, no-frills way to write .org files and convert them to .html.

My org-publish-project-alist now contains these entries:

("lbolla.info"
 :components ("lbolla.info-html" "lbolla.info-static" "lbolla.info-cv"))
("lbolla.info-static"
 :base-directory "~/src/lbolla.info/static/"
 :base-extension "png\\|jpg\\|\\|gif\\|gz\\|css"
 :publishing-directory "~/src/lbolla.info/html/"
 :recursive t
 :publishing-function org-publish-attachment)
("lbolla.info-cv"
 :base-directory "~/src/lbolla.info/org/"
 :exclude "\\.*"
 :include ("cv.org")
 :publishing-directory "~/src/lbolla.info/html/"
 :publishing-function org-latex-publish-to-pdf)
("lbolla.info-html"
 :base-directory "~/src/lbolla.info/org/"
 :publishing-directory "~/src/lbolla.info/html/"
 :recursive t
 :section-numbers nil
 :auto-sitemap t
 :sitemap-format-entry lbolla.info/org-publish-sitemap-format-entry
 :sitemap-function lbolla.info/org-publish-sitemap-function
 :sitemap-sort-files anti-chronologically
 :sitemap-style tree
 :sitemap-title "Sitemap"
 :with-toc nil
 :html-doctype "html5"
 :html-head-include-default-style nil
 :html-head-include-scripts nil
 :html-link-home "<ignored>"
 :html-link-up "<ignored>"
 :html-home/up-format "<div id=\"org-div-home-and-up\"><a accesskey=\"h\" href=\"/\">Home</a> | <a accesskey=\"a\" href=\"/articles\">Articles</a> | <a accesskey=\"c\" href=\"/cv\">CV</a> (<a href=\"/cv.pdf\">pdf</a>)</div>"
 :html-preamble lbolla.info/html-preamble
 :html-postamble nil
 :html-head "<link rel=\"stylesheet\" href=\"./css/org.css\" type=\"text/css\">"
 :html-head-extra "<link rel=\"stylesheet\" href=\"./css/extra.css\" type=\"text/css\">"
 :publishing-function org-html-publish-to-html)

Style is this one: some CSS rules made for org-generated HTML files.

Elixir pipe operator in Python

Wed, 25 May 2016 00:00:00 +0000

Elixir implements lots of nice ideas, one of which is its pipe operator. It allows you to write things like:

iex> [1, [2], 3] |> List.flatten()
[1, 2, 3]

Or:

iex> inc = fn x -> x + 1 end
iex> dec = fn x -> x - 1 end
iex> square = fn x -> x * x end
iex> 5 |> inc.() |> dec.() |> square.()
25

Today, just for fun, I tried to implement something similar in Python. Here is the result:

So, you can write something like:

>>> 5 |P| inc |P| dec |P| square
25

Obviously, this is just a toy: it does not implement all the features available in the Elixir's one, but it was fun!

Comparison of blocking and non-blocking Python multiprocessing Queue

Mon, 25 Apr 2016 00:00:00 +0000

Python's multiprocessing module offers a Queue implementation. Surprisingly enough (for me at least), its performance varies greatly if used in a blocking or non-blocking fashion. In particular, the non-blocking way is about ten times slower than the blocking one!

Consider this code, which feeds a Queue and then drains it in a blocking and non-blocking way:

Running it on my machine, with Python 2.7, gives me these results (Python 3.4 results are similar, but less dramatic):

Flycheck checker for Erlang dialyzer

Sat, 09 May 2015 00:00:00 +0000

Emacs Erlang mode misses the definition of a flycheck checker using dialyzer. Just add these lines to your .emacs to enable it:

I prefer to use it after the normal Erlang checker, so I define the following, too:

(flycheck-add-next-checker 'erlang 'erlang-dialyzer)

I also wrote another Flycheck checker if you are interested.

Enjoy!

EMpy 1.0 is out! Python3 compatible!

Sun, 26 Apr 2015 00:00:00 +0000

After a long sleep, I resumed development on Empy. The trigger was an appeal from Guido van Rossum at PyCon 2015 to package authors to support Python 3.

There are no new features to Empy, but I have:

ported the code to Python 3, using the amazing future library: now, both Python 2 and 3 are supported;
setup Travis CI to run unittest on all supported Python versions;
upgraded the dependencies to the latest available libraries;
Pylint'd and pep8'd the code
Renamed the package in PyPi to ElectroMagneticPython to avoid name conflicts with EmPy.

You can try it out by simply:

Flycheck checker for Flow

Wed, 19 Nov 2014 00:00:00 +0000

Yesterday Facebook open sourced Flow, a static type checker for Javascript. If you use Emacs, you can use Flycheck to check your .js files on the fly using Flow.

Here is the checker definition I use:

I prefer to use Flow after gjslint, so I define the following, too:

(flycheck-add-next-checker 'javascript-gjslint 'javascript-flow)

I also wrote another Flycheck checker if you are interested.

Enjoy!

Experiments in pickling

Wed, 14 May 2014 00:00:00 +0000

pickle is a standard library module to serialize and deserialize Python objects. Being written in pure Python, it's fairly slow, so the standard library provides a pure-C implementation, called cPickle, with the limitation that it cannot be subclassed.

What's interesting about cPickle are two little known settings that can speed up serialization quite substantially.

cPickle.HIGHEST_PROTOCOL basically dumps a Python object using a binary protocol, rather than the default ASCII-based, more portable, protocol 0. If portability or backward compatibility are not an issue for you, you should use it: it's documented and probably here to stay.

Die zombie, die!

Thu, 23 Jan 2014 00:00:00 +0000

The subprocess module in Python standard library allows you to spanw processes to do some tasks. The parent process should wait on its children processes in order get the return value of the process and avoid zombies.

Sometimes, though, processes are particularly hard to kill and even after a wait, a terminate or a kill they refuse to die: they become zombies.

In theory, Python should take care of reaping zombies for you once the zombie process gets garbage collected. In practice, it does not seem to work reliably and bigger weapons are needed.

Long running processes manager

Fri, 17 Jan 2014 00:00:00 +0000

If you want to run multiple processes in Python, the nicest way, in my opinion, is to use concurrent.futures (there is a backport for Python 2.x, too).

A problem that came up recently was to manage multiple long running processes, intended to run forever, from the same Python process. Using something like supervisord wouldn't be ideal, because each individual application would have its own config file and deployment procedure.

Instead, having just one "master" Python process to drive several other processes doing the job seemed the easiest solution to manage. The only caveat is that, being the processes managed long running, you want to restart them as soon as they die.

Overcoming Python GIL with Cython

Mon, 23 Dec 2013 00:00:00 +0000

Everybody is aware of the infamous Python's GIL. In a nutshell, the GIL is a global variable that prevents multiple threads to be run concurrently by the interpreter. Under some occasions, for certain operations, the interpreter releases the GIL therefore in certain cases this is not a problem. For example, the GIL is released before doing I/O, so I/O bound threads tend to run concurrently. Another example is when doing system calls. Unfortunately, for CPU bound tasks that don't make any I/O or system calls, the GIL prevents different threads from running concurrently, even on multicore CPUs. The astonishing thing is that, in fact, not only different threads do not run concurrently, but they also run slower on multicore CPUs than on single core ones!

Connect to MSSQL from Python with ODBC and FreeTDS

Thu, 29 Aug 2013 00:00:00 +0000

This is another of those posts that I wrote because I always forget how to do things…

This time, I don't want to forget how to connect from Python to MSSQL server anymore. In order to do it, you need the following system packages installed:

$> sudo apt-get install unixodbc-dev tdsodbc sqsh

sqsh installs all the required freetds-related libraries; tdsodbc is the FreeTDS driver for ODBC and unixodbc-dev is needed to install pyodbc.

Python and C with ctypes

Wed, 28 Aug 2013 00:00:00 +0000

Calling C code from Python is very simple using ctypes. Here is a very simple example to get you started and to serve as a reminder for me!

Let's say you have this C file, defining 3 functions:

foo which prints something to stdout;
bar which returns and int;
baz which takes a parameter and returns a value.

First, you want to compile this C file into a shared object. Here is a Makefile to do just this: simple type make all and you're done.

Simple chat with Postgres LISTEN NOTIFY and Tornado IOLoop

Thu, 21 Mar 2013 00:00:00 +0000

Postgres supports from version 8.4 a very interesting functionality: LISTEN/NOTIFY allows sending asynchronous messages to clients connected to the database.

As in a normal "chat", a client "subscribed" (LISTEN) to a channel receives all the messages that other clients "sent" (NOTIFY) on that channel.

Since version 9.0, a notification message can have a payload string as long as 8000 bytes.

In order to experiment with this feature, I've implemented a simple chat based on Tornado's IOLoop. Each client subscribes to a channel (or "room" in chat jargon) and listens to it adding a callback to react to a new notification. In the meantime, in another thread, the client is free to write and submit messages to the "room". Here is a screenshot of the chat in action:

Use Postgres advanced types in Python

Wed, 06 Mar 2013 00:00:00 +0000

Postgres has a lot of useful builtin data types, but only some of them are mapped to Python types when accessing the DB using psycopg2.

Extending the support to other types is not straightforward, and involves the following steps:

Create a Python class to store the data, e.g. class Point
Write a function to convert a Point to its SQL string representation, e.g. adapt_point
Write the inverse function to parse the SQL string representation of a Point and return and instance of a Point, e.g. cast_point
Finally bind all these functions and types, see register_point_type

The complete code is as follows, also available as a gist:

Blocking tasks in Tornado

Tue, 22 Jan 2013 00:00:00 +0000

Every now and then a new discussion is raised on Tornado's mailling list about what is the best way to execute blocking tasks. It turns out that there are 3 feasible options, in order of increasing complexity:

Optimize blocking calls. Often, a slow DB query, or an overly complicate template are the blocking bottleneck. Rather than complicating the webserver, the first thing to try is to speed them up. This is sufficient 99% of the time.
Execute the slow task in a separate thread or process. This means off-loading the task to a different thread (or process) to the one running the IOLoop, which is then free to accept other requests.
Use an asynchronous driver/library to run the task. For example, something like gevent, motor and the like.

This blog post is about the second option, in particular using Python's concurrent.futures package.

UnshareMe

Wed, 12 Dec 2012 00:00:00 +0000

Last my weekend project was to write something similar to WeHasLinks. In fact, WeHasLinks is a file sharing website, but I misread it as "We-Hash-Links" and the funny thing is that they indeed hash their links (for obvious reasons…). Anyway, WeHasLinks's links are hashed so that only the user who visited the page is allowed to them.

I liked the idea very much, and I decided to implement it in go, as an exercise! You can find the code on github. A demo is available at unshareme.lbolla.info.

Useful scripts - Watch

Fri, 30 Nov 2012 00:00:00 +0000

This is the fifth post of a series describing simple scripts that I wrote to ease my life as a programmer.

They are available on github: fork & hack at will!

Watch reacts to changes in a directory executing a command provided by the user. It can be used, for example, to monitor a directory and run some unittests as soon as files in it change. This is exactly how I am using Watch in acme.

Useful scripts - htmlind and xmlind

Fri, 23 Nov 2012 00:00:00 +0000

This is the forth post of a series describing simple scripts that I wrote to ease my life as a programmer.

In this post I'll describe 2 simple scripts to indent nicely HTML and XML files. I use them primarily with acme, to pipe selected text and get back nicely formatted output.

Code is available here: htmlind and xmlind. Both programs are written in Python and make use of specialized libraries freely available online. In particular, xmlind uses xml.dom.minidom, included in Python's standard library, and htmlind uses a modified version of BeautifulSoup.

Useful scripts - csvfmt, xmlfmt, jsonfmt

Fri, 16 Nov 2012 00:00:00 +0000

This is the third post of a series describing simple scripts that I wrote to ease my life as a programmer.

In this post, I'll describe 3 scripts to "pretty print" some common file types, to improve readability: csvfmt, xmlfmt and jsonfmt.

csvfmt takes a CSV ("Comma Separated Values") file from stdin, parses it and pretty print each record as a Python dictionary.

#!/usr/bin/env python

import csv
import sys
import pprint

for row in csv.DictReader(sys.stdin):
 pprint.pprint(row)

Output looks like this:

Wordpress to markdown

Mon, 12 Nov 2012 00:00:00 +0000

Recently, I moved away from Wordpress. I did it primarily because Wordpress is so much more than just a blogging platform and what I needed was just a simple way of publishing posts with embedded code, links and images. Moreover, writing blogs using Wordpress's web editor is less than ideal…

The biggest problem to solve when moving away from Wordpress is how to not lose all your posts. Luckily, Wordpress allows you to export all your stuff in XML, but you also need a way to import them in whatever other blogging platform you are going to use.

Useful scripts - c+-c-

Fri, 09 Nov 2012 00:00:00 +0000

This is the second post of a series describing simple scripts that I wrote to ease my life as a programmer.

They are available on github: fork & hack at will!

c+/c-

In this post I'll describe a very simple script, c+, and its counterpart c-.

c+ prepends every line of stdin with #. c- strips # from the beginning of each line of stdin. I use these scripts to comment/uncomment lines in Python scripts when using acme.

Useful scripts - a+-a-

Fri, 02 Nov 2012 00:00:00 +0000

This is the first post of a series describing simple scripts that I wrote to ease my life as a programmer.

They are implemented in various languages (python, bash, go) and thought to be used in Linux. Some of them are "general purpose", while others are specifically designed to interface other tools I use (for example, acme.)

All of them tend to have the following properties:

Input from stdin, output to stdout, errors to stderr
Return zero on success, non-zero on failure
Do one thing only
Not too much customizable

These properties allow the scripts to remain very simple, be composable and easy to remember.

URL Counter in GO

Wed, 10 Oct 2012 00:00:00 +0000

After having tinkered with #haskell for quite a bit, I decided that I needed some rest from theory and esoteric concepts, and a more pragmatic programming language to explore.

I've spent the last few days refreshing my memories on Go: I hadn’t touched it for almost 2 years and I must say that I find it changed: for the better.

Here is a short tutorial on how to write a simple web application in Go, and publish it on Google App Engine. The application is not a mere exercise, but scratches an itch I recently had: it counts how many times each of its handlers is hit. So, for example, visiting: http://go-count-urls.appspot.com/hello returns how many times the /hello handler has been visited. You can use it as a trivial real-time tracker.

Asynchronous programming with Tornado

Wed, 03 Oct 2012 00:00:00 +0000

Asynchronous programming can be tricky for beginners, therefore I think it's useful to iron some basic concepts to avoid common pitfalls. For an explanation about generic asynchronous programming, I recommend you one of the many resources online. I will focus solely on asynchronous programming in Tornado.

From Tornado's homepage:

FriendFeed's web server is a relatively simple, non-blocking web server written in Python. The FriendFeed application is written using a web framework that looks a bit like web.py or Google's webapp, but with additional tools and optimizations to take advantage of the non-blocking web server and tools. Tornado is an open source version of this web server and some of the tools we use most often at FriendFeed. The framework is distinct from most mainstream web server frameworks (and certainly most Python frameworks) because it is non-blocking and reasonably fast. Because it is non-blocking and uses epoll or kqueue, it can handle thousands of simultaneous standing connections, which means the framework is ideal for real-time web services. We built the web server specifically to handle FriendFeed's real-time features every active user of FriendFeed maintains an open connection to the FriendFeed servers. (For more information on scaling servers to support thousands of clients, see The C10K problem.)

Tornado vs. Warp vs. Yesod

Sun, 02 Sep 2012 00:00:00 +0000

Today I tried to benchmark 3 web servers that I've used recently:

In fact, these are only *2* web servers, because Yesod runs on top of Warp and it's a fully fledged web framework, rather than a web server: but this was also the intent of the benchmark, i.e. to measure how slower all its goodies made Yesod with respect to Warp.

Tornado and Warp are obviously very different web servers (async vs. threaded, interpreted vs. compiled, etc.) but, who cares?

EMpy has moved!

Mon, 25 Jun 2012 00:00:00 +0000

Empy has moved to Github!

Pipelines in Python

Fri, 20 Apr 2012 00:00:00 +0000

Generators (PEP 255 "Simple Generators") and Coroutines (PEP 342 "Coroutines via Enhanced Generators") are the cleanest way I've come across so far to implement the concept of a "pipeline" in Python.

First approximation

A pipeline is made of:

a Producer, that generates data;
many /Stage/s, that receive data from the previous stage and send it to the next;
a Consumer, that receives data from the last stage.

The producer is a coroutine that only /send/s data, generated internally from some initial state. /Stage/s are coroutines that both receive and send messages. The consumer only receives data. Chaining is done in function pipeline: each argument but the last is instantiated with an instance of the next stage. The full pipeline is started by issuing a next (or send(None)) to the Producer.

hsenv

Thu, 29 Mar 2012 00:00:00 +0000

If you have never used hsenv before, you should. It's basically the Haskell's equivalent of Python's virtualenv.

You can find a tweaked version of hsenv here: I've relaxed some requirements in order to make it install on newer GHC releases.

Finally, if when using you hit this error:

$ hsenv Creating Virtual Haskell directory structure
Installing GHC Initializing GHC Package database at /home/lollo/work/Unique/.hsenv/ghc_pkg_db
Copying necessary packages from original GHC package database
hsenv: fd:9: hGetContents: invalid argument (invalid byte sequence)
hsenv: thread blocked indefinitely in an MVar operation

Then, you have a problem with your locale. Follow the steps here, and retry.

Sudoku solver in Haskell

Mon, 27 Feb 2012 00:00:00 +0000

Recently, I've been challenged to write a Sudoku solver. Not knowing the rules and with only 30 minutes, I needed some help…

So, in case someone asks me again, I've implemented the same algorithm in Haskell.

I know that there are already a lot of other solutions, but, hey, it was fun!

HTTPS authentication in nginx

Mon, 20 Feb 2012 00:00:00 +0000

In order not to forget again how to setup http authentication in nginx here is a reminder.

For HTTPS follow these steps:

$ sudo -s
# cd /etc/nginx
# openssl req -new -x509 -nodes -out server.crt -keyout server.key

and add these lines to your server instance:

server {
 listen 443;
 ssl on;
 ssl_certificate /etc/nginx/server.crt;
 ssl_certificate_key /etc/nginx/server.key;
...

To setup basic authentication, add these lines to the same file:

location / {
 auth_basic "Restricted";
 auth_basic_user_file /etc/nginx/htpasswd;
 # you might also want to deny access based on IP here
 #allow <ip-address>;
 #deny all;
...

Finally, to generate /etc/nginx/htpasswd, use this one-liner:

ulint, Universal Lint

Thu, 05 Jan 2012 00:00:00 +0000

I've been using so many code static checkers lately, that I decided to write a wrapper around the ones I use the most. I called it: Universal Lint, ulint for short.

At the moment, Python, Javascript and Haskell files are supported, but adding new linters/extension is trivial.

Download it and use it!

HSGrep benchmarking

Wed, 30 Nov 2011 00:00:00 +0000

Few days ago, I rewrote sgrep in Haskell. I was curious to know how it compares to grep in term of execution speed. In particular, I was interested to verify that hsgrep scales as O(log n), instead of O(n), with n being the size of the file analyzed.

First of all, in order to have similar performance to grep, I had to convert my original program to use Haskell's bytestrings. You can find the code here. Testing files are generated with this script.

HSGrep Sorted grep in Haskell

Sun, 27 Nov 2011 00:00:00 +0000

As an exercise to learn Haskell, I wrote a specialized grep to work on sorted files. It uses binary search to scan a text file and print all the (consecutive) lines that start with a user defined string.

My program is a rewrite of sgrep in Haskell: I called it HSGrep. Code is available on github.

Thanks a lot for all your useful suggestions! As soon as possible, I'll post some benchmarking here. (EDIT: benchmarks now available!)

After downloading the source code, build install and run it with:

git pre-commit hook for Python and Javascript

Thu, 17 Nov 2011 00:00:00 +0000

Following a recent discussion on HN, I decided to share my own git pre-commit hook.

#!/usr/bin/python

import os
import sys
import re
import subprocess


devnull = open(os.devnull, 'w')


def call(cmd):
 p = subprocess.Popen(cmd.split(),
 stdout=subprocess.PIPE,
 stderr=subprocess.PIPE)
 out, err = p.communicate()
 return out.decode('utf-8'), err.decode('utf-8'), p.returncode


def execute(cmd, silent=False):
 if silent:
 params = {
 'stdout': devnull,
 'stderr': devnull,
 }
 else:
 params = {}

 retcode = subprocess.call(cmd.split(), **params)
 return retcode


def exists(cmd):
 return execute('which %s' % cmd, silent=True) == 0


def get_modified(ext):
 modified = re.compile('^(?:M|A).(?P<name>.*\.%s)' % ext)
 out, _, _ = call('git status --porcelain')
 modifieds = []
 for line in out.splitlines():
 match = modified.match(line.strip())
 if (match):
 modifieds.append(match.group('name'))
 return modifieds

It's a work-in-progress, so you can find the most updated version here. To use it, just drop it in your .git/hooks directory. At every git commit, it will run [pep8][4] and [pyflakes][5] on .py files, and [gjslint][6] on .js files.

Haskell and VIM

Sat, 15 Oct 2011 00:00:00 +0000

I had to tinker quite a bit before finding a decent configuration for vim to edit Haskell files. Here are the packages and config files I use:

Haskell mode: interaction with Haddock, compiler integration, and other general settings.
Indentation: proper source code indentation.
More configs to enforce good style (no tabs, tabstops, etc.):

You can also have them bundled all together.

They broke delicious

Fri, 30 Sep 2011 00:00:00 +0000

The new redesign of delicious.com broke so many things, that I thought I had to take notes:

bookmarklet in Chrome can't be drag-n-dropped to the toolbar. Its Javascript code is also hard to copy and paste to create the bookmarklet "manually".
install links for the chrome and Firefox extensions redirect to empty pages.
documentation for developer is coming soon (!)
the top-right menu with the logged-in username and stuff is the most horrible I've ever seen: it changes its width on hover, the corners look interrupted (in Chrome, at least – I'm not bothered trying with other browsers)
what the hell are stacks? Grouping can be done with tags, already, and I don't want that much space in the page taken by a "social" feature! Who needs it?
the list of links in the main personal page only shows 8 links on my screen… 8 links?! There's way too much padding, too whitespaces, too much to scroll… It's a bookmarking services, it should show you bookmarks in the most friendly way!
image: why should I use an image for myself? And if I don't use one, I got assigned one by default… Please…

I'll add more to the list in the future.

HTTP client in Haskell

Mon, 26 Sep 2011 00:00:00 +0000

To try to make sense of this, I decided to write a "simple" http client in Haskell in as many styles as I could think of:

import Network.HTTP
import Control.Applicative

url = "http://www.haskell.org/haskellwiki/Haskell"

-- Imperative style
fetch_1 = do
 rsp <- Network.HTTP.simpleHTTP (getRequest url)
 body <- getResponseBody rsp
 return (take 1000 body)

-- With Functors' fmap
fetch_2 = do
 rsp <- Network.HTTP.simpleHTTP (getRequest url)
 fmap (take 1000) (getResponseBody rsp)

-- With Applicative's >>=
fetch_3 = fmap (take 1000) (Network.HTTP.simpleHTTP (getRequest url) >>= getResponseBody)

-- "fmap f x" is the same as "pure f <*> x" (Applicative's law)
fetch_4 = pure (take 1000) <*> (Network.HTTP.simpleHTTP (getRequest url) >>= getResponseBody)

-- "pure f <*> x" is the same as "f <$> x"
fetch_5 = (take 1000) <$> (Network.HTTP.simpleHTTP (getRequest url) >>= getResponseBody)

It's a long time since I found so many new concepts while studying a new programming language…

pylint.vim

Thu, 25 Aug 2011 00:00:00 +0000

vim + Python + pylint is a powerful combination, especially when using this vim plugin. Unfortunately, the script stopped working after a pylint upgrade:

$ pylint --version
pylint 0.24.0,
astng 0.22.0, common 0.56.0
Python 2.7.2 (default, Jun 29 2011, 11:10:00)
[GCC 4.6.1]

You can download the fixed version here!

If interested, the patch looks like this:

diff pylint.vim.orig pylint.vim
69c69
< CompilerSet makeprg=(echo\ '[%]';\ pylint\ -r\ y\ %)
---
> CompilerSet makeprg=(echo\ '[%]';\ pylint\ -r\ y\ --output-format=parseable\
> %)
74c74
< CompilerSet efm=%+P[%f],%t:\ %#%l:%m,%Z,%+IYour\ code%m,%Z,%-G%.%#
---
> CompilerSet efm=%f:%l:\ [%t]%m,%f:%l:%m

MD5 vs SHA1 in Python

Wed, 24 Aug 2011 00:00:00 +0000

If you are interested to know if the myth about MD5 being faster than SHA1 holds for Python, here is the result I got on my box:

In [1]: import hashlib
In [2]: %timeit hashlib.md5('text text text').hexdigest()
1000000 loops, best of 3: 1.29 us per loop
In [3]: %timeit hashlib.sha1('text text text').hexdigest()
1000000 loops, best of 3: 1.4 us per loop

Result is: MD5 is faster, but only just, in Python 2.7.2. Considering that MD5 is broken, I think I'll use SHA1…

sleepsort

Fri, 17 Jun 2011 00:00:00 +0000

To honor the funniest thread in months, here is a lisp implementation of sleepsort!

(use-package :sb-thread)

(defun show (item)
 (sleep item)
 (format t "~S~%" item))

(defun sleep-sort (lst)
 (mapcar
 #'(lambda (item) (make-thread #'(lambda () (show item))))
 lst))

Javascript templating benchmark

Mon, 23 May 2011 00:00:00 +0000

There are many popular libraries to do templating in Javascript.

The most popular are:

I decided to benchmark them, so I created a simple "hello world" test.

As usual, the results are interesting. Here are, on my box:

	Firefox 3.6	Chrome 11.0	Safari 5.0
jQuery Template	297ms	138ms	113ms
Pure	309ms	43ms	36ms
Resig	309ms	41ms	41ms
Trimpath	15ms	5ms	6ms
JQote2	7ms	1ms	6ms

A part from the obvious result that Firefox is the slowest browser of all, I'm astonished by the excellent performance of JQote2!

Related to... Andrew Lloyd Webber!

Tue, 12 Apr 2011 00:00:00 +0000

It looks like I'm related to Andrew Lloyd Webber! Funny it's in Portuguese, though…

Get registered domain in Python and Javascript

Tue, 05 Apr 2011 00:00:00 +0000

reg-dom-libs are a set of libraries for C, PHP and Perl to convert an arbitrary domain name to the registered domain name.

For simple domains, like www.amazon.com or news.ycombinator.com, the task is trivial.
For more complicated ones, like www.ebay.co.uk or www.japantimes.co.jp, handling the second level subdomain is a little painful.
For exoteric ones, like nic.com.ai or www.nic.net.ge or 公司.cn, the problem becomes virtually impossible.
After seeing stupid ones, like www.comune.caserta.it (believe it or not, the registered domain is comune.caserta.it!), I gave up finding an elegant algorithm for the problem.
A full list of valid registered domain is necessary. Luckily, it is available (and nightly updated) here.

Inspired by reg-dom-libs, I've ported the algorithm to Python and Javascript. See the tests at the end of each file for an example of the usage. A demo is available here.

Handling an iframe from the inside

Wed, 30 Mar 2011 00:00:00 +0000

If you've ever worked with iframes you've certainly run into the same origin policy.

From here:

The same origin policy basically limits how scripts and frames on different domains can talk to each other.

This is particularly bad if you want to resize an iframe to accomodate its content, as this is not doable with simple CSS (to the best of my knowledge!). It can be done using window.postMessage, though.

See a demo here.

twill revived

Fri, 11 Mar 2011 00:00:00 +0000

After reading how to do automated testing in python, I've started using twill, by C. Titus Brown

twill is a simple language that allows users to browse the Web from a command-line interface. With twill, you can navigate through Web sites that use forms, cookies, and most standard Web features.

Unfortunately, development on twill seems to have stopped 3 years ago.

I've cloned the project on Github, fixed some deprecation warnings and added a cool new feature to inspect headers, as well as html.

Year 2038 bug in MySQL

Fri, 04 Mar 2011 00:00:00 +0000

Today I hit the "year 2038" bug. While working on MySQL, I did something like:

mysql> create table y2038 (x timestamp);

mysql> insert into y2038 values ('1900-01-01');
Query OK, 1 row affected, 1 warning (0.04 sec)

mysql> insert into y2038 values ('2050-01-01');
Query OK, 1 row affected, 1 warning (0.04 sec)

mysql> select * from y2038;
+---------------------+
| x |
+---------------------+
| 0000-00-00 00:00:00 |
| 0000-00-00 00:00:00 |
+---------------------+
2 row in set (0.00 sec)

mysql> drop table y2038; -- damn

It turned out that MySQL's TIMESTAMP only accepts dates between 1970-01-01 00:00:01 and 2038-01-19 03:14:07: everything outside this range will be truncated.

SBCL quicker than C?

Sun, 05 Dec 2010 00:00:00 +0000

After reading a nice conversation on comp.lang.lisp I decided to play a little bit with SBCL and Debian's Shootout Benchmarks.

I considered the spectral norm benchmark and compared the C and SBCL implementations.

I started re-running the tests without any further optimization and the results were similar to the ones reported with C beating SBCL by a factor of 2. (for the C optimization used, see here).

Then, I noticed that there was no =(declaim (optimize (speed 3) (safety 0) (space 0)))= in the SBCL file! I've added it and rerun the test. Here are my results:

Find hyperlinks with lisp

Sun, 24 Oct 2010 00:00:00 +0000

Here is a quick-and-dirty script to extract all the unique links from a web page.

It uses cl-ppcre to extract the hyperlinks-like strings from a target string. Tested using drakma as web client.

(asdf:oos 'asdf:load-op :drakma)
(asdf:oos 'asdf:load-op :cl-ppcre)

(defparameter *url-re* "href *= *['"](\S+)['"]")

(defun find-links (str)
 (let ((urls '()))
 (ppcre:do-register-groups
 (u) (*url-re* str nil :start 0 :sharedp t)
 (pushnew u urls :test #'equalp))
 (nreverse urls)))

(print
 (find-links (drakma:http-request "http://lbolla.wordpress.com")))

There are 139 links on this page…

lisp threading example

Sat, 23 Oct 2010 00:00:00 +0000

Today I wanted to experiment with threads in lisp (sbcl, in particular).

Here is a trivial example of how to access a shared resource (a closure, keeping a list of integers), from a set of *nt* threads.

(use-package :sb-thread)

;; number of threads
(defparameter *nt* 10)

;; threads
(defvar *threads* '())

;; mutex to use with shared resource accessed by the threads
(defvar *a-mutex* (make-mutex :name "acc-lock"))

;; shared closure accessed by the threads
(let ((x '()))
 (defun acc (v)
 (with-mutex (*a-mutex*)
 (push v x)))
 (defun get-acc ()
 x))

;; print the shared resource
(print (get-acc))

;; wait for all the threads to return
(mapcar #'join-thread
 ;; run the threads
 (loop :for i :below *nt* 
 ;; bind i to x so it is local to the thread
 :collect (let ((x i))
 (make-thread #'(lambda ()
 ;; body of the thread
 (sleep (random 2))
 (acc x))
 :name x))))

;; print the shared resource
(print (get-acc))

It can't get much simpler than that…

Simple Wordpress API lisp client

Wed, 04 Aug 2010 00:00:00 +0000

I like old things, therefore I started to learn Lisp.

There isn't a better way to learn than by doing, so I tried to implement a client for the wordpress api. the result, even if not complete yet, it's so elegant that I'd like to share it.

(require 's-xml-rpc)

(defpackage :wp 
 (:use :cl :cl-user :s-xml-rpc))

(in-package :wp)

(defparameter +interfaces+ 
 '((get-blogs "wp.getUsersBlogs" username password)
 (get-tags "wp.getTags" blog-id username password)
 (get-comment-count "wp.getCommentCount" blog-id username password post-id)
 (get-post-status-list "wp.getPostStatusList" blog-id username password)
 (get-page-status-list "wp.getPageStatusList" blog-id username password)
 (get-page-templates "wp.getPageTemplates" blog-id username password)
 (get-options "wp.getOptions" blog-id username password)
 (delete-comment "wp.deleteComment" blog-id username password comment-id)
 (get-comment-status-list "wp.getCommentStatusList" blog-id username password)
 (get-page "wp.getPage" blog-id page-id username password)
 (get-pages "wp.getPages" blog-id username password)
 (get-page-list "wp.getPageList" blog-id username password)
 (delete-page "wp.deletePage" blog-id username password page-id)
 (get-authors "wp.getAuthors" blog-id username password)
 (get-categories "wp.getCategories" blog-id username password)
 (delete-category "wp.deleteCategory" blog-id username password category-id)
 (suggest-categories "wp.suggestCategories" blog-id username password category max-results)
 (get-comment "wp.getComment" blog-id username password comment-id))
 "Interface definition to WP services")

(defun defunwp (params) 
 (destructuring-bind (name service &rest rest) params
 (setf (fdefinition name) (compile nil `(lambda (host ,@rest &optional (url "/xmlrpc.php")) 
 (block ,name 
 (xml-rpc-call 
 (encode-xml-rpc-call ,service ,@rest)
 :host host
 :url url)))))
 name))

(mapcar #'(lambda (interface) (export (defunwp interface))) +interfaces+)

It uses the s-xml-rpc package and I've tested it with SBCL.

Missing `Dec_0` and friends from Python Decimal

Thu, 29 Jul 2010 00:00:00 +0000

This fails in py2.4, py2.5.1 and py2.6:

from decimal import Dec_0

But it works in all the other py2.5 subversions!

It seems that exposing Dec_0 (and other similar constants) was considered a bug and "fixed" on Jan 3rd 2009 by renaming it _Dec_0.

Indeed, if I had looked at the source code, I would have seen that Dec_0 was for "internal use only".

From /usr/lib/python2.5/decimal.py:5159

# Reusable defaults
Inf = Decimal('Inf')
negInf = Decimal('-Inf')
NaN = Decimal('NaN')
Dec_0 = Decimal(0)
Dec_p1 = Decimal(1)
Dec_n1 = Decimal(-1)

Those definitions are missing in py2.4 and py2.5.1, and renamed in py2.6.

Wordpress Python library

Sun, 06 Jun 2010 00:00:00 +0000

Today, I found this. It's a wonderfully simple Python library to manage your Wordpress blog via XML-RPC.

Enjoy!

Editors speed on opening big files

Mon, 17 May 2010 00:00:00 +0000

While playing with different editors (namely vim and sam) I tried to time how long some common editors take to open a big file (~140Mb).

Then, for curiosity, I timed less with and without (-n) line numbering:

Here are the results:

editor	real	user	sys
`ed`	4.866s	3.440s	3.440s
`vim`	2.086s	0.836s	0.232s
`nano`	16.264s	15.361s	0.172s
`sam`	way too long
`less`	3.552s	0.200s	0.072s
`less -n`	0.182s	0.016s	0.016s

Not sure what to do with these numbers, yet…

Trivial terminal speed benchmark

Thu, 29 Apr 2010 00:00:00 +0000

Today, while playing with st, I tried a very simple benchmark. Here it is:

$> time seq -f 'teeeeeeeeeeeeeeeeeeeeeeeeeeeeeest %g' 999999

Here are the results:

xterm: 0m28.508s
rxvt: 0m8.568s
st: 0m12.082s

All the terminals shared the same fonts, but xterm and rxvt had saveLines=1024 set for scrolling purposes, feature that st lacks.

Being st at such an early stage of development, I think this is a good result.

surf browser hints -3

Sat, 09 Jan 2010 00:00:00 +0000

Another couple of hints about surf, after my previous post.

Honestly, I stopped using surf after 0.3 release. I think that the authors stripped out of the code too much sugar that, not being suckless, was nonetheless useful: a status bar showing the current URI, for example. Now URI editing is done via xprop and dmenu, which is great piece of software, but not always user friendly (it does not have editing capabilities).

Moreover bookmarking is a pain as it relies on external shell scripts. Or does it not? I realized that there is no need to use external shell scripts, as they can be "embedded" in C code. Here is how.

Installing pcf fonts in X

Thu, 07 Jan 2010 00:00:00 +0000

As I keep forgetting, here is how to install pcf fonts in X

Create a new directory for the fonts, usually under /usr/share/fonts:

$> mkdir /usr/share/fonts/

Copy the pcf file(s) into it (sometimes the pcf files are gzipped):

$> cp /path/to/pcf/*.pcf* /usr/share/fonts/

Run mkfontdir, to create a fonts.dir file, used by X to find font files

$> mkfontdir /usr/share/fonts/

Add the new dir to X font path. The easiest way to do it is to stick this line in your .xinitrc:

xset fp+ /usr/share/fonts/

Now your new font should compare in xfontsel and you should be able to use it as normal.

surf browser hints -2

Tue, 25 Aug 2009 00:00:00 +0000

Following yesterday's post, here is another useful hint about surf's usage.

The following script lists the available bookmarks (from ~/.bookmarks file) and let's you pick one using dmenu. If a new link is inserted, it is added to the list of known bookmarks, so you won't need to type it in full the next time:

#!/bin/sh
bookmarks=~/.bookmarks
link=`cat $bookmarks | dmenu ${1+"$@"}` || exit 0
present=`grep $link $bookmarks`
if [ "$?" -ne "0" ]; then
 echo $link >> $bookmarks
fi
surf -u $link

If you don't want to open a new window, just change the last line to set the _SURF_URL X Property of the surf window you want to use (by clicking on it):

surf browser hints

Mon, 24 Aug 2009 00:00:00 +0000

surf is a simple web browser based on webkit/gtk+, the same web engine that powers Google Chrome. Used with dwm and dmenu, it's a very powerful, yet simple tool.

Here is a patch to apply X geometry hints to surf, so that surf windows behave in dwm.

*** surf.c.orig 2009-08-24 16:41:31.000000000 +0100
--- surf.c 2009-08-24 16:35:02.000000000 +0100
***************
*** 372,377 ****
--- 372,381 ----
gtk_container_add(GTK_CONTAINER(c->vbox), c->searchbar);
gtk_container_add(GTK_CONTAINER(c->vbox), c->urlbar);

+ /* Hints */
+ GdkGeometry hints = { 1, 1 };
+ gtk_window_set_geometry_hints(GTK_WINDOW(c->win), NULL, &hints,
 GDK_HINT_MIN_SIZE);
+
/* Setup */
gtk_box_set_child_packing(GTK_BOX(c->vbox), c->urlbar, FALSE, FALSE, 0,
GTK_PACK_START);
gtk_box_set_child_packing(GTK_BOX(c->vbox), c->searchbar, FALSE, FALSE, 0,
GTK_PACK_START);

Another hint is to create a script to feed surf with your favorite bookmarks.

vim and Python comments

Wed, 12 Aug 2009 00:00:00 +0000

I'm currently undergoing a profound revision (read "cleanup") of my .vimrc and I recently had to choose a decent plug-in to comment python code.

The best so far is EnhancedCommentify. It's highly configurable, powerful and it supports a different number of languages (not only python).

The only one thing that wasn't easy to setup if the behaviour described here: being able to comment a block, respecting the indent, in both visual and normal mode.

Test with gnome-blog

Tue, 03 Feb 2009 00:00:00 +0000

This is a post using gnome-blog, a weblog client for gnome. Here I read about this possibility, but there were no instructions about how to configure the client…

If this is published, it can't be so difficult…

qwerty vs dvorak vs colemak to edit Python code

Mon, 02 Feb 2009 00:00:00 +0000

Yesterday, I was intrigued by the idea of choosing a more efficient keyboard layout to work with everyday. As long as I type Python code 90% of my time, I decided to evaluate the efficiency of the first 3 most widespread keyboard layouts: QWERTY, Dvorak and Colemak. I used this excellent tool to compare the three layouts over the first 50000 characters of the webpy source code. Here are the results:

 <div id="page">
 <div id="text">
 <h1>
The Qwerty Keyboard Layout Vs The Dvorak Keyboard Layout
 </h1>
 <h2 style="font-size: 90%;">
:: UP ::Overall effort
 </h2>
 <table>
 <thead class="small">
 <tr>
 <td class="a1">
Layout
 </td>
 <td class="a0">
Effort
 </td>
 <td class="a1">


% improvement over worst layout


 </td>
 <td class="a0"></td>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="a1">


Qwerty


 </td>
 <td class="a0" style="text-align: right;">


306,509.6


 </td>
 <td class="a1" style="text-align: right;">


0.0 %


 </td>
 <td class="a0"></td>
 </tr>
 <tr>
 <td class="a1">


Dvorak


 </td>
 <td class="a0" style="text-align: right;">


283,868.7


 </td>
 <td class="a1" style="text-align: right;">


7.4 %


 </td>
 <td class="a0"></td>
 </tr>
 <tr>
 <td class="a1">


Colemak


 </td>
 <td class="a0" style="text-align: right;">


275,347.6


 </td>
 <td class="a1" style="text-align: right;">


10.2 %


 </td>
 <td class="a0"></td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::Keys for each finger (stronger fingers should be used more often)


 </h2>
 <table>
 <thead class="small">
 <tr>
 <td class="a1">


Layout


 </td>
 <td class="a0">


Thumbs


 </td>
 <td class="a1">


LPinky


 </td>
 <td class="a0">


LRing


 </td>
 <td class="a1">


LMiddle


 </td>
 <td class="a0">


LIndex


 </td>
 <td class="a1">


RIndex


 </td>
 <td class="a0">


RMiddle


 </td>
 <td class="a1">


RRing


 </td>
 <td class="a0">


RPinky


 </td>
 <td class="a1">


Total


 </td>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="a1">


Qwerty


 </td>
 <td class="a0" style="text-align: right;">


25.9 %


 </td>
 <td class="a1" style="text-align: right;">


12.4 %


 </td>
 <td class="a0" style="text-align: right;">


5.3 %


 </td>
 <td class="a1" style="text-align: right;">


9.5 %


 </td>
 <td class="a0" style="text-align: right;">


11.6 %


 </td>
 <td class="a1" style="text-align: right;">


7.6 %


 </td>
 <td class="a0" style="text-align: right;">


5.6 %


 </td>
 <td class="a1" style="text-align: right;">


8.9 %


 </td>
 <td class="a0" style="text-align: right;">


13.2 %


 </td>
 <td class="a1" style="text-align: right;">


54,237.0 keys


 </td>
 </tr>
 <tr>
 <td class="a1">


Dvorak


 </td>
 <td class="a0" style="text-align: right;">


25.9 %


 </td>
 <td class="a1" style="text-align: right;">


13.0 %


 </td>
 <td class="a0" style="text-align: right;">


5.2 %


 </td>
 <td class="a1" style="text-align: right;">


8.1 %


 </td>
 <td class="a0" style="text-align: right;">


7.3 %


 </td>
 <td class="a1" style="text-align: right;">


7.5 %


 </td>
 <td class="a0" style="text-align: right;">


7.5 %


 </td>
 <td class="a1" style="text-align: right;">


8.2 %


 </td>
 <td class="a0" style="text-align: right;">


17.3 %


 </td>
 <td class="a1" style="text-align: right;">


54,237.0 keys


 </td>
 </tr>
 <tr>
 <td class="a1">


Colemak


 </td>
 <td class="a0" style="text-align: right;">


25.9 %


 </td>
 <td class="a1" style="text-align: right;">


12.7 %


 </td>
 <td class="a0" style="text-align: right;">


4.8 %


 </td>
 <td class="a1" style="text-align: right;">


7.5 %


 </td>
 <td class="a0" style="text-align: right;">


9.5 %


 </td>
 <td class="a1" style="text-align: right;">


8.4 %


 </td>
 <td class="a0" style="text-align: right;">


10.1 %


 </td>
 <td class="a1" style="text-align: right;">


6.6 %


 </td>
 <td class="a0" style="text-align: right;">


14.5 %


 </td>
 <td class="a1" style="text-align: right;">


54,237.0 keys


 </td>
 </tr>
 </tbody>
 </table>
 <table>
 <thead class="small">
 <tr>
 <td class="a1">


Layout


 </td>
 <td class="a0">


Thumbs


 </td>
 <td class="a1">


Left hand


 </td>
 <td class="a0">


Right hand


 </td>
 <td class="a1">


Total


 </td>
 <td class="a0"></td>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="a1">


Qwerty


 </td>
 <td class="a0" style="text-align: right;">


25.9 %


 </td>
 <td class="a1" style="text-align: right;">


38.8 %


 </td>
 <td class="a0" style="text-align: right;">


35.2 %


 </td>
 <td class="a1" style="text-align: right;">


54,237.0 keys


 </td>
 <td class="a0"></td>
 </tr>
 <tr>
 <td class="a1">


Dvorak


 </td>
 <td class="a0" style="text-align: right;">


25.9 %


 </td>
 <td class="a1" style="text-align: right;">


33.6 %


 </td>
 <td class="a0" style="text-align: right;">


40.5 %


 </td>
 <td class="a1" style="text-align: right;">


54,237.0 keys


 </td>
 <td class="a0"></td>
 </tr>
 <tr>
 <td class="a1">


Colemak


 </td>
 <td class="a0" style="text-align: right;">


25.9 %


 </td>
 <td class="a1" style="text-align: right;">


34.5 %


 </td>
 <td class="a0" style="text-align: right;">


39.6 %


 </td>
 <td class="a1" style="text-align: right;">


54,237.0 keys


 </td>
 <td class="a0"></td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::Finger Travel Distance (only the horizontal)


 </h2>
 <table>
 <thead class="small">
 <tr>
 <td class="a1">


Layout


 </td>
 <td class="a0">


Thumbs


 </td>
 <td class="a1">


LPinky


 </td>
 <td class="a0">


LRing


 </td>
 <td class="a1">


LMiddle


 </td>
 <td class="a0">


LIndex


 </td>
 <td class="a1">


RIndex


 </td>
 <td class="a0">


RMiddle


 </td>
 <td class="a1">


RRing


 </td>
 <td class="a0">


RPinky


 </td>
 <td class="a1">


Total


 </td>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="a1">


Qwerty


 </td>
 <td class="a0" style="text-align: right;">


0.0 %


 </td>
 <td class="a1" style="text-align: right;">


18.1 %


 </td>
 <td class="a0" style="text-align: right;">


2.0 %


 </td>
 <td class="a1" style="text-align: right;">


10.5 %


 </td>
 <td class="a0" style="text-align: right;">


15.5 %


 </td>
 <td class="a1" style="text-align: right;">


12.1 %


 </td>
 <td class="a0" style="text-align: right;">


8.6 %


 </td>
 <td class="a1" style="text-align: right;">


9.9 %


 </td>
 <td class="a0" style="text-align: right;">


23.4 %


 </td>
 <td class="a1" style="text-align: right;">


1,441.5 m


 </td>
 </tr>
 <tr>
 <td class="a1">


Dvorak


 </td>
 <td class="a0" style="text-align: right;">


0.0 %


 </td>
 <td class="a1" style="text-align: right;">


21.1 %


 </td>
 <td class="a0" style="text-align: right;">


4.1 %


 </td>
 <td class="a1" style="text-align: right;">


3.5 %


 </td>
 <td class="a0" style="text-align: right;">


10.0 %


 </td>
 <td class="a1" style="text-align: right;">


12.5 %


 </td>
 <td class="a0" style="text-align: right;">


7.6 %


 </td>
 <td class="a1" style="text-align: right;">


10.8 %


 </td>
 <td class="a0" style="text-align: right;">


30.4 %


 </td>
 <td class="a1" style="text-align: right;">


1,210.3 m


 </td>
 </tr>
 <tr>
 <td class="a1">


Colemak


 </td>
 <td class="a0" style="text-align: right;">


0.0 %


 </td>
 <td class="a1" style="text-align: right;">


23.7 %


 </td>
 <td class="a0" style="text-align: right;">


2.5 %


 </td>
 <td class="a1" style="text-align: right;">


6.1 %


 </td>
 <td class="a0" style="text-align: right;">


10.2 %


 </td>
 <td class="a1" style="text-align: right;">


10.2 %


 </td>
 <td class="a0" style="text-align: right;">


9.3 %


 </td>
 <td class="a1" style="text-align: right;">


9.3 %


 </td>
 <td class="a0" style="text-align: right;">


28.6 %


 </td>
 <td class="a1" style="text-align: right;">


1,131.2 m


 </td>
 </tr>
 </tbody>
 </table>
 <table>
 <thead class="small">
 <tr>
 <td class="a1">


Layout


 </td>
 <td class="a0">


Thumbs


 </td>
 <td class="a1">


Left hand


 </td>
 <td class="a0">


Right hand


 </td>
 <td class="a1">


Total


 </td>
 <td class="a0"></td>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="a1">


Qwerty


 </td>
 <td class="a0" style="text-align: right;">


0.0 %


 </td>
 <td class="a1" style="text-align: right;">


46.0 %


 </td>
 <td class="a0" style="text-align: right;">


54.0 %


 </td>
 <td class="a1" style="text-align: right;">


1,441.5 m


 </td>
 <td class="a0"></td>
 </tr>
 <tr>
 <td class="a1">


Dvorak


 </td>
 <td class="a0" style="text-align: right;">


0.0 %


 </td>
 <td class="a1" style="text-align: right;">


38.8 %


 </td>
 <td class="a0" style="text-align: right;">


61.2 %


 </td>
 <td class="a1" style="text-align: right;">


1,210.3 m


 </td>
 <td class="a0"></td>
 </tr>
 <tr>
 <td class="a1">


Colemak


 </td>
 <td class="a0" style="text-align: right;">


0.0 %


 </td>
 <td class="a1" style="text-align: right;">


42.6 %


 </td>
 <td class="a0" style="text-align: right;">


57.4 %


 </td>
 <td class="a1" style="text-align: right;">


1,131.2 m


 </td>
 <td class="a0"></td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::% home keys (out of all character keys plus SHIFT and ENTER, but excluding keys operated by thumbs)


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


Qwerty


 </td>
 <td style="text-align: right;">


20.4 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Dvorak


 </td>
 <td style="text-align: right;">


33.7 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Colemak


 </td>
 <td style="text-align: right;">


38.7 %


 </td>
 <td class="bar"></td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::% keys typed with the same finger as the previous key (excluding repeating keys like ss)


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


Qwerty


 </td>
 <td style="text-align: right;">


4.5 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Dvorak


 </td>
 <td style="text-align: right;">


3.8 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Colemak


 </td>
 <td style="text-align: right;">


3.6 %


 </td>
 <td class="bar"></td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::% keys typed with the same hand as the previous key (ex: in Qwerty sd or ss are included, but s s is not since you type the space with the other hand)


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


Qwerty


 </td>
 <td style="text-align: right;">


26.8 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Dvorak


 </td>
 <td style="text-align: right;">


20.0 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Colemak


 </td>
 <td style="text-align: right;">


24.6 %


 </td>
 <td class="bar"></td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::% keys typed with the same hand as the previous key and jumping a row (ex: in Qwerty ev is a row jump -- you jump over the middle row -- and it's awkward to type; ef is not a row jump)


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


Qwerty


 </td>
 <td style="text-align: right;">


10.3 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Dvorak


 </td>
 <td style="text-align: right;">


5.7 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Colemak


 </td>
 <td style="text-align: right;">


4.1 %


 </td>
 <td class="bar"></td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::% keys typed with the same hand as the previous key and in reverse order (ex: in Qwerty df or kj are typed in the easier order pinky-ring-middle-index, whereas fd and jk are in reverse order index-middle-ring-pinky, and harder to type)


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


Qwerty


 </td>
 <td style="text-align: right;">


15.4 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Dvorak


 </td>
 <td style="text-align: right;">


11.9 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Colemak


 </td>
 <td style="text-align: right;">


15.2 %


 </td>
 <td class="bar"></td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::% keys that need the SHIFT modifier


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


Qwerty


 </td>
 <td style="text-align: right;">


14.3 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Dvorak


 </td>
 <td style="text-align: right;">


14.3 %


 </td>
 <td class="bar"></td>
 </tr>
 <tr>
 <td>


Colemak


 </td>
 <td style="text-align: right;">


14.3 %


 </td>
 <td class="bar"></td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::Pairs of consecutive keys typed with the same finger in Qwerty


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


:/NewLine/


 </td>
 <td style="text-align: right;">


253 times


 </td>
 <td style="text-align: right;">


0.47 %


 </td>
 </tr>
 <tr>
 <td>


de


 </td>
 <td style="text-align: right;">


200 times


 </td>
 <td style="text-align: right;">


0.37 %


 </td>
 </tr>
 <tr>
 <td>


tr


 </td>
 <td style="text-align: right;">


158 times


 </td>
 <td style="text-align: right;">


0.29 %


 </td>
 </tr>
 <tr>
 <td>


rt


 </td>
 <td style="text-align: right;">


102 times


 </td>
 <td style="text-align: right;">


0.19 %


 </td>
 </tr>
 <tr>
 <td>


ol


 </td>
 <td style="text-align: right;">


99 times


 </td>
 <td style="text-align: right;">


0.18 %


 </td>
 </tr>
 <tr>
 <td>


un


 </td>
 <td style="text-align: right;">


98 times


 </td>
 <td style="text-align: right;">


0.18 %


 </td>
 </tr>
 <tr>
 <td>


q\_LeftShift\_


 </td>
 <td style="text-align: right;">


87 times


 </td>
 <td style="text-align: right;">


0.16 %


 </td>
 </tr>
 <tr>
 <td>


ce


 </td>
 <td style="text-align: right;">


86 times


 </td>
 <td style="text-align: right;">


0.16 %


 </td>
 </tr>
 <tr>
 <td>


“/NewLine/


 </td>
 <td style="text-align: right;">


81 times


 </td>
 <td style="text-align: right;">


0.15 %


 </td>
 </tr>
 <tr>
 <td>


ed


 </td>
 <td style="text-align: right;">


80 times


 </td>
 <td style="text-align: right;">


0.15 %


 </td>
 </tr>
 <tr>
 <td>


}/NewLine/


 </td>
 <td style="text-align: right;">


62 times


 </td>
 <td style="text-align: right;">


0.11 %


 </td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::Pairs of consecutive keys typed with the same finger in Dvorak


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


ct


 </td>
 <td style="text-align: right;">


196 times


 </td>
 <td style="text-align: right;">


0.36 %


 </td>
 </tr>
 <tr>
 <td>


s\_RightShift\_


 </td>
 <td style="text-align: right;">


169 times


 </td>
 <td style="text-align: right;">


0.31 %


 </td>
 </tr>
 <tr>
 <td>


db


 </td>
 <td style="text-align: right;">


152 times


 </td>
 <td style="text-align: right;">


0.28 %


 </td>
 </tr>
 <tr>
 <td>


l\_RightShift\_


 </td>
 <td style="text-align: right;">


137 times


 </td>
 <td style="text-align: right;">


0.25 %


 </td>
 </tr>
 <tr>
 <td>


‘/LeftShift/


 </td>
 <td style="text-align: right;">


133 times


 </td>
 <td style="text-align: right;">


0.25 %


 </td>
 </tr>
 <tr>
 <td>


rn


 </td>
 <td style="text-align: right;">


115 times


 </td>
 <td style="text-align: right;">


0.21 %


 </td>
 </tr>
 <tr>
 <td>


ls


 </td>
 <td style="text-align: right;">


100 times


 </td>
 <td style="text-align: right;">


0.18 %


 </td>
 </tr>
 <tr>
 <td>


}/NewLine/


 </td>
 <td style="text-align: right;">


62 times


 </td>
 <td style="text-align: right;">


0.11 %


 </td>
 </tr>
 <tr>
 <td>


=/RightShift/


 </td>
 <td style="text-align: right;">


59 times


 </td>
 <td style="text-align: right;">


0.11 %


 </td>
 </tr>
 <tr>
 <td>


“/LeftShift/


 </td>
 <td style="text-align: right;">


58 times


 </td>
 <td style="text-align: right;">


0.11 %


 </td>
 </tr>
 <tr>
 <td>


e.


 </td>
 <td style="text-align: right;">


58 times


 </td>
 <td style="text-align: right;">


0.11 %


 </td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::Pairs of consecutive keys typed with the same finger in Colemak


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


:/NewLine/


 </td>
 <td style="text-align: right;">


253 times


 </td>
 <td style="text-align: right;">


0.47 %


 </td>
 </tr>
 <tr>
 <td>


ue


 </td>
 <td style="text-align: right;">


237 times


 </td>
 <td style="text-align: right;">


0.44 %


 </td>
 </tr>
 <tr>
 <td>


db


 </td>
 <td style="text-align: right;">


152 times


 </td>
 <td style="text-align: right;">


0.28 %


 </td>
 </tr>
 <tr>
 <td>


e,


 </td>
 <td style="text-align: right;">


89 times


 </td>
 <td style="text-align: right;">


0.16 %


 </td>
 </tr>
 <tr>
 <td>


q\_LeftShift\_


 </td>
 <td style="text-align: right;">


87 times


 </td>
 <td style="text-align: right;">


0.16 %


 </td>
 </tr>
 <tr>
 <td>


“/NewLine/


 </td>
 <td style="text-align: right;">


81 times


 </td>
 <td style="text-align: right;">


0.15 %


 </td>
 </tr>
 <tr>
 <td>


}/NewLine/


 </td>
 <td style="text-align: right;">


62 times


 </td>
 <td style="text-align: right;">


0.11 %


 </td>
 </tr>
 <tr>
 <td>


]/NewLine/


 </td>
 <td style="text-align: right;">


46 times


 </td>
 <td style="text-align: right;">


0.08 %


 </td>
 </tr>
 <tr>
 <td>


pt


 </td>
 <td style="text-align: right;">


44 times


 </td>
 <td style="text-align: right;">


0.08 %


 </td>
 </tr>
 <tr>
 <td>


‘/RightShift/


 </td>
 <td style="text-align: right;">


41 times


 </td>
 <td style="text-align: right;">


0.08 %


 </td>
 </tr>
 <tr>
 <td>


“/RightShift/


 </td>
 <td style="text-align: right;">


41 times


 </td>
 <td style="text-align: right;">


0.08 %


 </td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::Key frequency in your text


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


/Space/


 </td>
 <td style="text-align: right;">


14067 times


 </td>
 <td style="text-align: right;">


25.94 %


 </td>
 </tr>
 <tr>
 <td>


/LeftShift/


 </td>
 <td style="text-align: right;">


4391 times


 </td>
 <td style="text-align: right;">


8.10 %


 </td>
 </tr>
 <tr>
 <td>


e


 </td>
 <td style="text-align: right;">


3239 times


 </td>
 <td style="text-align: right;">


5.97 %


 </td>
 </tr>
 <tr>
 <td>


t


 </td>
 <td style="text-align: right;">


2184 times


 </td>
 <td style="text-align: right;">


4.03 %


 </td>
 </tr>
 <tr>
 <td>


s


 </td>
 <td style="text-align: right;">


2170 times


 </td>
 <td style="text-align: right;">


4.00 %


 </td>
 </tr>
 <tr>
 <td>


r


 </td>
 <td style="text-align: right;">


1890 times


 </td>
 <td style="text-align: right;">


3.48 %


 </td>
 </tr>
 <tr>
 <td>


a


 </td>
 <td style="text-align: right;">


1619 times


 </td>
 <td style="text-align: right;">


2.99 %


 </td>
 </tr>
 <tr>
 <td>


o


 </td>
 <td style="text-align: right;">


1557 times


 </td>
 <td style="text-align: right;">


2.87 %


 </td>
 </tr>
 <tr>
 <td>


l


 </td>
 <td style="text-align: right;">


1530 times


 </td>
 <td style="text-align: right;">


2.82 %


 </td>
 </tr>
 <tr>
 <td>


n


 </td>
 <td style="text-align: right;">


1519 times


 </td>
 <td style="text-align: right;">


2.80 %


 </td>
 </tr>
 <tr>
 <td>


/NewLine/


 </td>
 <td style="text-align: right;">


1511 times


 </td>
 <td style="text-align: right;">


2.79 %


 </td>
 </tr>
 <tr>
 <td>


i


 </td>
 <td style="text-align: right;">


1372 times


 </td>
 <td style="text-align: right;">


2.53 %


 </td>
 </tr>
 <tr>
 <td>


/RightShift/


 </td>
 <td style="text-align: right;">


1357 times


 </td>
 <td style="text-align: right;">


2.50 %


 </td>
 </tr>
 <tr>
 <td>


d


 </td>
 <td style="text-align: right;">


1014 times


 </td>
 <td style="text-align: right;">


1.87 %


 </td>
 </tr>
 <tr>
 <td>


f


 </td>
 <td style="text-align: right;">


971 times


 </td>
 <td style="text-align: right;">


1.79 %


 </td>
 </tr>
 <tr>
 <td>


c


 </td>
 <td style="text-align: right;">


855 times


 </td>
 <td style="text-align: right;">


1.58 %


 </td>
 </tr>
 <tr>
 <td>


u


 </td>
 <td style="text-align: right;">


851 times


 </td>
 <td style="text-align: right;">


1.57 %


 </td>
 </tr>
 <tr>
 <td>


m


 </td>
 <td style="text-align: right;">


716 times


 </td>
 <td style="text-align: right;">


1.32 %


 </td>
 </tr>
 <tr>
 <td>


p


 </td>
 <td style="text-align: right;">


715 times


 </td>
 <td style="text-align: right;">


1.32 %


 </td>
 </tr>
 <tr>
 <td>


(


 </td>
 <td style="text-align: right;">


674 times


 </td>
 <td style="text-align: right;">


1.24 %


 </td>
 </tr>
 <tr>
 <td>


)


 </td>
 <td style="text-align: right;">


673 times


 </td>
 <td style="text-align: right;">


1.24 %


 </td>
 </tr>
 <tr>
 <td>


.


 </td>
 <td style="text-align: right;">


658 times


 </td>
 <td style="text-align: right;">


1.21 %


 </td>
 </tr>
 <tr>
 <td>


‘


 </td>
 <td style="text-align: right;">


623 times


 </td>
 <td style="text-align: right;">


1.15 %


 </td>
 </tr>
 <tr>
 <td>


,


 </td>
 <td style="text-align: right;">


573 times


 </td>
 <td style="text-align: right;">


1.06 %


 </td>
 </tr>
 <tr>
 <td>


b


 </td>
 <td style="text-align: right;">


571 times


 </td>
 <td style="text-align: right;">


1.05 %


 </td>
 </tr>
 <tr>
 <td>


“


 </td>
 <td style="text-align: right;">


563 times


 </td>
 <td style="text-align: right;">


1.04 %


 </td>
 </tr>
 <tr>
 <td>


\_


 </td>
 <td style="text-align: right;">


554 times


 </td>
 <td style="text-align: right;">


1.02 %


 </td>
 </tr>
 <tr>
 <td>


=


 </td>
 <td style="text-align: right;">


518 times


 </td>
 <td style="text-align: right;">


0.96 %


 </td>
 </tr>
 <tr>
 <td>


:


 </td>
 <td style="text-align: right;">


490 times


 </td>
 <td style="text-align: right;">


0.90 %


 </td>
 </tr>
 <tr>
 <td>


q


 </td>
 <td style="text-align: right;">


463 times


 </td>
 <td style="text-align: right;">


0.85 %


 </td>
 </tr>
 <tr>
 <td>


y


 </td>
 <td style="text-align: right;">


423 times


 </td>
 <td style="text-align: right;">


0.78 %


 </td>
 </tr>
 <tr>
 <td>


h


 </td>
 <td style="text-align: right;">


416 times


 </td>
 <td style="text-align: right;">


0.77 %


 </td>
 </tr>
 <tr>
 <td>


w


 </td>
 <td style="text-align: right;">


352 times


 </td>
 <td style="text-align: right;">


0.65 %


 </td>
 </tr>
 <tr>
 <td>


>


 </td>
 <td style="text-align: right;">


348 times


 </td>
 <td style="text-align: right;">


0.64 %


 </td>
 </tr>
 <tr>
 <td>


g


 </td>
 <td style="text-align: right;">


304 times


 </td>
 <td style="text-align: right;">


0.56 %


 </td>
 </tr>
 <tr>
 <td>


v


 </td>
 <td style="text-align: right;">


257 times


 </td>
 <td style="text-align: right;">


0.47 %


 </td>
 </tr>
 <tr>
 <td>


x


 </td>
 <td style="text-align: right;">


253 times


 </td>
 <td style="text-align: right;">


0.47 %


 </td>
 </tr>
 <tr>
 <td>


k


 </td>
 <td style="text-align: right;">


231 times


 </td>
 <td style="text-align: right;">


0.43 %


 </td>
 </tr>
 <tr>
 <td>


<


 </td>
 <td style="text-align: right;">


154 times


 </td>
 <td style="text-align: right;">


0.28 %


 </td>
 </tr>
 <tr>
 <td>


/


 </td>
 <td style="text-align: right;">


125 times


 </td>
 <td style="text-align: right;">


0.23 %


 </td>
 </tr>
 <tr>
 <td>


[]


 </td>
 <td style="text-align: right;">


119 times


 </td>
 <td style="text-align: right;">


0.22 %


 </td>
 </tr>
 <tr>
 <td>


;


 </td>
 <td style="text-align: right;">


113 times


 </td>
 <td style="text-align: right;">


0.21 %


 </td>
 </tr>
 <tr>
 <td>


0


 </td>
 <td style="text-align: right;">


86 times


 </td>
 <td style="text-align: right;">


0.16 %


 </td>
 </tr>
 <tr>
 <td>


`


 </td>
 <td style="text-align: right;">


85 times


 </td>
 <td style="text-align: right;">


0.16 %


 </td>
 </tr>
 <tr>
 <td>


+


 </td>
 <td style="text-align: right;">


84 times


 </td>
 <td style="text-align: right;">


0.15 %


 </td>
 </tr>
 <tr>
 <td>


1


 </td>
 <td style="text-align: right;">


81 times


 </td>
 <td style="text-align: right;">


0.15 %


 </td>
 </tr>
 <tr>
 <td>


{


 </td>
 <td style="text-align: right;">


80 times


 </td>
 <td style="text-align: right;">


0.15 %


 </td>
 </tr>
 <tr>
 <td>


}


 </td>
 <td style="text-align: right;">


79 times


 </td>
 <td style="text-align: right;">


0.15 %


 </td>
 </tr>
 <tr>
 <td>


-


 </td>
 <td style="text-align: right;">


78 times


 </td>
 <td style="text-align: right;">


0.14 %


 </td>
 </tr>
 <tr>
 <td>


j


 </td>
 <td style="text-align: right;">


76 times


 </td>
 <td style="text-align: right;">


0.14 %


 </td>
 </tr>
 <tr>
 <td>


*


 </td>
 <td style="text-align: right;">


72 times


 </td>
 <td style="text-align: right;">


0.13 %


 </td>
 </tr>
 <tr>
 <td>


#


 </td>
 <td style="text-align: right;">


69 times


 </td>
 <td style="text-align: right;">


0.13 %


 </td>
 </tr>
 <tr>
 <td>


2


 </td>
 <td style="text-align: right;">


67 times


 </td>
 <td style="text-align: right;">


0.12 %


 </td>
 </tr>
 <tr>
 <td>


%


 </td>
 <td style="text-align: right;">


55 times


 </td>
 <td style="text-align: right;">


0.10 %


 </td>
 </tr>
 <tr>
 <td>


$


 </td>
 <td style="text-align: right;">


52 times


 </td>
 <td style="text-align: right;">


0.10 %


 </td>
 </tr>
 <tr>
 <td>


3


 </td>
 <td style="text-align: right;">


31 times


 </td>
 <td style="text-align: right;">


0.06 %


 </td>
 </tr>
 <tr>
 <td>


6


 </td>
 <td style="text-align: right;">


29 times


 </td>
 <td style="text-align: right;">


0.05 %


 </td>
 </tr>
 <tr>
 <td>


8


 </td>
 <td style="text-align: right;">


18 times


 </td>
 <td style="text-align: right;">


0.03 %


 </td>
 </tr>
 <tr>
 <td>


@


 </td>
 <td style="text-align: right;">


17 times


 </td>
 <td style="text-align: right;">


0.03 %


 </td>
 </tr>
 <tr>
 <td></td>
 <td style="text-align: right;">


14 times


 </td>
 <td style="text-align: right;">


0.03 %


 </td>
 </tr>
 <tr>
 <td>


z


 </td>
 <td style="text-align: right;">


13 times


 </td>
 <td style="text-align: right;">


0.02 %


 </td>
 </tr>
 <tr>
 <td>


5


 </td>
 <td style="text-align: right;">


13 times


 </td>
 <td style="text-align: right;">


0.02 %


 </td>
 </tr>
 <tr>
 <td>


4


 </td>
 <td style="text-align: right;">


8 times


 </td>
 <td style="text-align: right;">


0.01 %


 </td>
 </tr>
 <tr>
 <td>


?


 </td>
 <td style="text-align: right;">


8 times


 </td>
 <td style="text-align: right;">


0.01 %


 </td>
 </tr>
 <tr>
 <td>


9


 </td>
 <td style="text-align: right;">


7 times


 </td>
 <td style="text-align: right;">


0.01 %


 </td>
 </tr>
 </tbody>
 </table>
 <hr />
 <h2 style="font-size: 90%;">


:: UP ::Frequent pairs of keys in your text


 </h2>
 <table>
 <tbody>
 <tr>
 <td>


\_Space\_\_Space\_


 </td>
 <td style="text-align: right;">


9243 times


 </td>
 <td style="text-align: right;">


17.04 %


 </td>
 </tr>
 <tr>
 <td>


\_NewLine\_\_Space\_


 </td>
 <td style="text-align: right;">


1233 times


 </td>
 <td style="text-align: right;">


2.27 %


 </td>
 </tr>
 <tr>
 <td>


\_Space\_\_LeftShift\_


 </td>
 <td style="text-align: right;">


805 times


 </td>
 <td style="text-align: right;">


1.48 %


 </td>
 </tr>
 <tr>
 <td>


/LeftShift/(


 </td>
 <td style="text-align: right;">


674 times


 </td>
 <td style="text-align: right;">


1.24 %


 </td>
 </tr>
 <tr>
 <td>


/LeftShift/)


 </td>
 <td style="text-align: right;">


673 times


 </td>
 <td style="text-align: right;">


1.24 %


 </td>
 </tr>
 <tr>
 <td>


/LeftShift/”


 </td>
 <td style="text-align: right;">


563 times


 </td>
 <td style="text-align: right;">


1.04 %


 </td>
 </tr>
 <tr>
 <td>


\_LeftShift\_\_


 </td>
 <td style="text-align: right;">


554 times


 </td>
 <td style="text-align: right;">


1.02 %


 </td>
 </tr>
 <tr>
 <td>


se


 </td>
 <td style="text-align: right;">


549 times


 </td>
 <td style="text-align: right;">


1.01 %


 </td>
 </tr>
 <tr>
 <td>


,/Space/


 </td>
 <td style="text-align: right;">


543 times


 </td>
 <td style="text-align: right;">


1.00 %


 </td>
 </tr>
 <tr>
 <td>


/LeftShift/:


 </td>
 <td style="text-align: right;">


490 times


 </td>
 <td style="text-align: right;">


0.90 %


 </td>
 </tr>
 <tr>
 <td>


el


 </td>
 <td style="text-align: right;">


405 times


 </td>
 <td style="text-align: right;">


0.75 %


 </td>
 </tr>
 <tr>
 <td>


er


 </td>
 <td style="text-align: right;">


377 times


 </td>
 <td style="text-align: right;">


0.70 %


 </td>
 </tr>
 <tr>
 <td>


in


 </td>
 <td style="text-align: right;">


364 times


 </td>
 <td style="text-align: right;">


0.67 %


 </td>
 </tr>
 <tr>
 <td>


\_Space\_\_RightShift\_


 </td>
 <td style="text-align: right;">


362 times


 </td>
 <td style="text-align: right;">


0.67 %


 </td>
 </tr>
 <tr>
 <td>


or


 </td>
 <td style="text-align: right;">


352 times


 </td>
 <td style="text-align: right;">


0.65 %


 </td>
 </tr>
 <tr>
 <td>


/LeftShift/>


 </td>
 <td style="text-align: right;">


348 times


 </td>
 <td style="text-align: right;">


0.64 %


 </td>
 </tr>
 <tr>
 <td>


/Space/i


 </td>
 <td style="text-align: right;">


344 times


 </td>
 <td style="text-align: right;">


0.63 %


 </td>
 </tr>
 <tr>
 <td>


/Space/s


 </td>
 <td style="text-align: right;">


341 times


 </td>
 <td style="text-align: right;">


0.63 %


 </td>
 </tr>
 <tr>
 <td>


te


 </td>
 <td style="text-align: right;">


340 times


 </td>
 <td style="text-align: right;">


0.63 %


 </td>
 </tr>
 <tr>
 <td>


e\_LeftShift\_


 </td>
 <td style="text-align: right;">


338 times


 </td>
 <td style="text-align: right;">


0.62 %


 </td>
 </tr>
 <tr>
 <td>


=/Space/


 </td>
 <td style="text-align: right;">


332 times


 </td>
 <td style="text-align: right;">


0.61 %


 </td>
 </tr>
 <tr>
 <td>


/Space/=


 </td>
 <td style="text-align: right;">


321 times


 </td>
 <td style="text-align: right;">


0.59 %


 </td>
 </tr>
 <tr>
 <td>


re


 </td>
 <td style="text-align: right;">


306 times


 </td>
 <td style="text-align: right;">


0.56 %


 </td>
 </tr>
 <tr>
 <td>


lf


 </td>
 <td style="text-align: right;">


294 times


 </td>
 <td style="text-align: right;">


0.54 %


 </td>
 </tr>
 <tr>
 <td>


)/NewLine/


 </td>
 <td style="text-align: right;">


281 times


 </td>
 <td style="text-align: right;">


0.52 %


 </td>
 </tr>
 <tr>
 <td>


e\_Space\_


 </td>
 <td style="text-align: right;">


281 times


 </td>
 <td style="text-align: right;">


0.52 %


 </td>
 </tr>
 </tbody>
 </table>
 </div>

Actually, I was disappointed: there seem to be no clear advantage of Dvorak or Colemak, wrt QWERTY and, given the popularity of the latter, switching does not seem to be a good idea…

This is another weblog client test

Sun, 01 Feb 2009 00:00:00 +0000

…and this is using BloGTK, which seems a little bit better. It support tags, too!

Better…

Tab completion in Python shell

Wed, 25 Jun 2008 00:00:00 +0000

Recently I saw with this little piece of code to give the standard python shell tab completion capabilities:

# setup tab completion in python shell
import rlcompleter
import readline
readline.parse_and_bind("tab: complete")

Obviously, you can use the environmental variable PYTHONSTART to execute this few lines anytime you start your python shell.

Enjoy!

Memoize

Thu, 17 Apr 2008 00:00:00 +0000

Recently, from a discussion on the scipy-user group I discovered a very elegant way to code a function with memory.

Let's state the problem. Suppose you need a function that remembers, for each time it has been called, the input parameters and its output. This can be very useful in many different situations:

If it is very expensive to evaluate, you can check its memory to see if it has been previously evaluated and, if yes, get its return value without actually calling it.
Inside an optimization loop, to remember all the intermediate steps of the optimization.
To accumulate data on the behaviour of the function itself.
To surprise friends ;-)

The function's memory can be as long as the program's running time, or it can be "permanent" if hard-coded in a file. Starting from here I've put together a couple of useful classes in python that can be used as decorators.

India!

Thu, 10 Apr 2008 00:00:00 +0000

http://maps.google.com/staticmap?center=18.979025953255267,80.244140625&markers=28.635308,77.22496,red|9.927708,76.266918,red|27.177719,78.0093,red|25.282009,82.956337,red|12.61645,80.194031,red|10.78482,79.142029,red|8.400502,76.979828,red|9.913986,78.121727,red|9.286719,79.311633,red|8.084033,77.54187,red|&zoom=4&size=500x500&key=ABQIAAAAITb_ASiA6dCkZ7VuJlkzPhTq9fk25wIGSg_6hAqtwa_NWPtb7xRZ02wBNfD7jZf92ZjlbxH8CRwtMQ

Dopo lunghe pensate, ecco l'itinerario! Dal 26 aprile al 16 maggio.

IQ test

Sat, 02 Feb 2008 00:00:00 +0000

Qualche giorno fa, mi sono imbattuto in questo test di intelligenza, proposto da ECM. Riporto il testo, per semplicita':

Using each of the numbers 1, 2, 3, 4, 5, 6, 7, 8, 9 only once, form a nine digit number A that can satisfy the following criteria:

A is exactly divisible by 9.

Removing the rightmost digit from A forms an eight digit number B that is exactly divisible by 8.

Removing the rightmost digit from B forms a seven digit number C that is exactly divisible by 7.

Mon, 24 Dec 2007 00:00:00 +0000

http://www.informit.com/ShowCover.aspx?isbn=0789737256&type=a

Finalmente, sembra che Photopedia stia per uscire anche in italia! Conterra' una delle mie prime fotografie digitali, che potete trovare qui (rigorosamente sotto Creative Commons License).

Potenza della rete…

Photopedia

Mon, 24 Dec 2007 00:00:00 +0000

http://www.informit.com/ShowCover.aspx?isbn=0789737256&type=a

Finalmente, sembra che Photopedia stia per uscire anche in italia! Conterra' una delle mie prime fotografie digitali, che potete trovare qui (rigorosamente sotto Creative Commons License).

Potenza della rete…

EMpy

Thu, 27 Sep 2007 00:00:00 +0000

EMpy is out! Here is the release note:

I'm very pleased to announce the release of EMpy (Electromagnetic Python), a suite of numerical algorithms widely used in electromagnetism.

The package, in its very-alpha stage by now, only contains the transfer matrix and the rigorous coupled wave analysis algorithms, and some handy functions and classes (to model materials, for examples). The idea is to expand it in the near future with new algorithms and interfaces to existent software. The package is based on Numpy/Scipy and its homepage: http://empy.sourceforge.net.

Numerical computing Matlab vs Python + numpy + weave

Wed, 11 Apr 2007 00:00:00 +0000

Recently, I've discovered the power of Python for numerical computing. Being a slave of Matlab for many years, I've decided to give Python (and it's numerical module numpy) a try, comparing its number crunching capabilities versus Matlab's.

The tests are heavily inspired by Prabhu Ramachandran. I've only added Matlab to complete his comparisons.

Here is a short description of the test, taken from here:

The example we will consider is a very simple (read, trivial) case of solving the 2D Laplace equation using an iterative finite difference scheme (four point averaging, Gauss-Seidel or Gauss-Jordan). The formal specification of the problem is as follows.

Il Metodo

Wed, 14 Feb 2007 00:00:00 +0000

Il primo era di non prendere mai niente per vero, se non ciò che io avessi chiaramente riconosciuto come tale; ovvero, evitare accuratamente la fretta e il pregiudizio, e di non comprendere nel mio giudizio niente di più di quello che fosse presentato alla mia mente così chiaramente e distintamente da escludere ogni possibilità di dubbio.

Il secondo, di dividere ognuna delle difficoltà sotto esame nel maggior numero di parti possibile, e per quanto fosse necessario per un'adeguata soluzione.

Google Docs

Wed, 11 Oct 2006 00:00:00 +0000

Cool! Google has launched a new service, called "Google Docs&Spreadsheets": http://docs.google.com. They are merging two different services already available (Writely and Spreadsheets) into one suite: at the very end, they are providing free a simplified online Office Suite.

One nice feature is that you can post your docs on your blog in just few clicks. This post is the witness…

Wouldn't be nice to have just one "editor" on the web that any website can interface to? Just like Vi in *nix? Pretty clever, though.

Maestro

Wed, 30 Aug 2006 00:00:00 +0000

Sometimes people find you.

Sunday, I saw a documentary about Henri Cartier-Bresson. I must admit I had never heard about him: photography has never been an interest for me. But his photographs were mesmerizing. When, walking in the city center, thinking about decisive moments and how to picture them, I stopped in front of an exhibition. It was about photography. It was about Henri Cartier-Bresson.

From never heard before, to be met twice in a day. Shouldn't we follow coincidences? I like his philosophy: photograph is like an instant painting. The most important thing is the instant: the "decisive moment". Even if he was a reporter, he was convinced that reporting is not art. It's too much about informing. It's for everyone. Art is different, for few should like it. His photos inspired many people.

Ontologisches Beweis

Fri, 11 Aug 2006 00:00:00 +0000

Ass.1: P(φ).P(ψ) ⊃ P(φ.ψ)
Ass.2: P(φ) ∨ P(-φ)

Def.1: G(x) ≡ (φ)[P(φ) ⊃ φ(x)]
Def.2: φ Ess. x ≡ (ψ)[ψ(x) ⊃ N(y){φ(y) ⊃ ψ(y)]]

Ass.3a: P(φ) ⊃ NP(φ)
Ass.3b: ∼P(φ) ⊃ N∼P(φ)

Theo.1: G(x) ⊃ G Ess. x

Def.3: E(x) ≡ (φ)[φ Ess. x ⊃ N(∃x) φ(x)]

Ass.4: P(E)

Theo.2: G(x) ⊃ N(∃y)G(y)

Therefore:
(∃x)G(x) ⊃ N(∃y)G(y)
M(∃x)G(x) ⊃ MN(∃y)G(y)
M(∃x)G(x) ⊃ N(∃y)G(y)

Ass.5: P(φ).N(φ⊃ψ):⊃P(ψ)

Gödel, 1970

mi-vr-mi

Sun, 14 May 2006 00:00:00 +0000

http://static.flickr.com/56/146087373_8241e23cec.jpg?v=0

First road trip by motorbike, this weekend: from Milan to Verona and back. You can see the photos here: one shot every 10 km, whatever there was… (taken by my new camera! Lot's of news since the last time!)

Motorbiking is relaxing and relaxing makes me think. So, while driving back home, I realized that there is a fundamental difference between motorcyclists and "car's drivers": Solidarity. If a motorcyclist has a problem other motorcyclists stop to help him, if he is OK others keep greeting him. Can you imagine that with "car's drivers"? In Italy??