This is why I use a simple technique for getting stuff done called the Pomodoro Technique.

The Pomodoro Technique gets its intriguing name from kitchen timers, which are often shaped like tomatoes (“pomodoro” means tomato in Italian). The inventor of this technique (i.e., Francesco Cirillo) used just such a timer to keep track of his time as he focused on his university studies, and this fact inspired the Pomodoro’s moniker.

This productivity hack is extremely simple, and can be used when programming, writing, or doing any task that’s important to you.

How the Pomodoro Technique works

The basic idea is that each of us can only focus on a given task for so long before we become distracted. This time management technique also weaves in the fact that it’s important to take regular breaks as you work (both for the sake of helping you stay focused and for your overall health and well-being). The Pomodoro Technique regulates when you are to diligently focus on a task and when you should take a breather.

This technique is centered around breaking your time down into pomodori (one pomodoro is equal to 25 minutes). You log a specific task you are going to work on and then sprint your way through that pomodoro. After 25 minutes of dedicated work, the timer goes off and you take a nice 5 minute break from your work.

You must name a pomodoro before starting the timer

Once your break is over, you start another 25 minute long pomodoro. This new pomodoro can be dedicated to the same task as before (if you didn’t complete it during the previous pomodoro) or a new one. After every 4 pomodori (plural for pomodoro), you can take a longer break, if you’d like (such as for 15 minutes).

While you’re working your way through a pomodoro, you can temporally interrupt it for up to 45 seconds, if need be. If the interruption last for longer than that, your dedicated focus on the main task is viewed to be lost, and thus the pomodoro is reset (having to start over at 25 minutes) again.

The defaults of 25 minutes per pomodoro, 5 minutes per regular break, 15 minutes per longer break, and 45 seconds per interruption seem to work well for me and most people I know who’ve tried this handy technique out. However, that said, those arbitrary allotments of time can be changed depending on you personal habits and schedule, so as long as you consistently stick with the allotments that you’ve laid out. For example, some people may prefer to work “in the zone” for 50 minutes, and then take a 10 minute break.

It’s important not to ignore breaks, as they really help you to stay refreshed as you jump into your next 25 minute Pomodoro sprint.

Advantages of using this productivity technique

In trying out this simple, but highly effective technique, I’ve discovered several benefits that have lead me on to keep using it for a long time.

The Pomodoro Technique forces you to think in terms of actions that needs to be taken in order to effectively get things done. It also imposes that you prioritize and decide which action you’re going to work on right now. By helping to limit your attention span to a single activity, this technique aides you in staying focused (instead of hopping between a handful of different tasks and/or distractions).

Revisiting your daily or weekly pomodoro logs will clearly highlight where you spent your time and how productive you were throughout a given time period.

Armed with the Pomodoro Technique, you’ll start to think in terms of the number of pomodori that a given task might require. As you gain experience, you’ll soon discover that even challenging tasks can often be taken care of in a handful of pomodori sessions.

For example, I once replied to about 100 personal emails that I had been putting off for a while. I was worried it would take me a whole weekend (or longer!) to catch up on this backlog, however in reality it only took six pomodori during a Saturday morning to reach the mythical state of Inbox Zero.

If you do the math, that’s an impressive average of 90 seconds per email, Once I started replying, it was clear that I’d really gotten the ball rolling and thus felt more inclined to send “short and sweet” email replies as I productively worked my way through each pomodoro.

In my experience, the advantages above, help you beat procrastination by reinforcing how these distraction-less pomodoro sprints can aid you in completing huge tasks in easy-to-manage blocks of time. Once you’ve established a track record of accomplishing tough jobs in a handful of pomodori, you will be less apprehensive of approaching seemingly huge jobs in the future (and thus less likely to put them off for later).

Using the Pomodoro Technique also helped me better quantify the level of distraction present within our interruption driven workplace. If you’re determined to get a pomodori done, you’ll find a way to limit the number of unnecessary interruptions and actually focus on the task at hand. If you don’t, you’ll quickly see how there is a huge discrepancy between the number of pomodori you are supposed to complete in a productive work day, and how many you actually finish as a result of all the interruptions from colleagues, notification programs, and the attractive muse we call Internet.

While doing numerous highly productive 25 minute sprints in one day will drain your energy more than if you just causally jogged your way throughout the work day, it is seriously rewarding to see just how much you can get done in so little time.

Pomodoro Technique software

The Pomodoro Technique could literally be executed with any (household or computer based) timer and a piece of paper (on which to track and log your pomodori). It is however much more convenient to use software that’s been specifically designed with this (increasingly popular amongst developers) technique in mind.

Personally I use Pomodoro for Mac, which costs $4.99 from the Mac App Store (older versions are available for free, but don’t offer the same range of features). Pomodoro for Mac is extremely customizable, and even integrates with iCal, Things, OmniFocus, Twitter and so on.

If you are not on a Mac, there are other applications for virtually any platform (including Android and iOS) out there. While some of these are less polished and have less features than the Mac app, it’s important to remember than even a simple timer application and a text editor would do the trick, so you don’t actually need all the bells and whistles of the Mac version.

I found that my mind naturally adopted the Pomodoro Technique quickly, welcoming the chance to solidly concentrate on a certain task for a set period without the time anxiety or the shiny allure of distractions and excessive multi-tasking hovering around me. I use the Pomodoro Technique frequently and credit it with helping me to better manage my time and get more out of my work days. It’s simple to try and is well worth test-driving if you’re looking for a productive way to stay focused and really make the most of your time.

And last but not least, for those who might be wondering, this article was written and published in two pomodori.

Bibliography

USA | UK | Canada	USA | UK | Canada | Free PDF

No related posts.

In case you are curious about who the students are, they’re Marius Butuc from Romania, and Henrique Zambon from Brazil. They’re good guys, feel free to follow them on Twitter (even though Henrique’s stream may be more interesting to you if you speak Portuguese).

The selection process

I received about 100 resumes from students around the globe who wanted to apply for the internship. Of those, I invited the 50 most promising applicants to have an initial phone interview, as I wanted to give a fair chance to everyone (yet at the same time, I didn’t want get the hopes up of those who clearly didn’t have a shot, and thus the remaining applicants were informed that they hadn’t made the initial cut).

Before their first interviews took place, I assigned the 50 preselected candidates a coding project. They could either develop a CSV to HTML converter, a search client using Twitter’s API, or an S3 uploader.

While none of these exercises were rocket science, they were intended to provide us with an general idea of the students’ ability to code. Most candidates went for the CSV to HTML converter. Some chose the Twitter client, and a tiny handful opted for the S3 uploader (one ambitious candidate delivered all three).

After carefully reviewing their code, I held the technical interviews with all of the candidates who had sent in their assignments. During the first interview I asked each person a series of very technical questions, and in some instances we also discussed their assignments. In most cases each interview lasted for an hour.

After the initial round of interviews had wrapped up, I selected the 10 most promising candidates for a second phone call and informed the others that they wouldn’t be continuing on with the interview process.

For the second round of interviews I was joined by my manager, and together we conducted phone calls with each candidate that were based less on the each person’s technical skills. This second interview was meant to test their soft skills, to get a feel for their interests, and to assess their overall attitude.

There were important interviews because they helped us get to know the candidates a bit better. Our aim was to learn about what excited these eager applicants, to see their level of passion for programming, and to observe other skills that were not strictly related to coding. We also discussed the project they’d be working on if they were selected, our team approach (we are more of an Agile startup than the stereotypical image you may have of IBM), and discussed details of the next steps with each of these ten candidates.

At this point Leon (my manager) and I discussed at length which two applicants we wanted to select. All ten students were top notch candidates, so the choice wasn’t an easy one for us. We ended up considering every single bit of information at our disposal about the students, from their their resumes and past experiences to their performance with the technical assignment, what (human and programming) languages they knew, and how they’d faired with both of the interviews.

After a lot of consideration, we ended up selecting Marius and Henrique. (In case you’re wondering, the student who did all three assignment was also from Romania and he was ultimately our third choice, had either Marius or Henrique been unable to accept the internship position.)

What I learned from reviewing so many candidates

• When you receive 100 resumes from very good students from around the world, you quickly come to realize that it’s surprisingly hard to determine someone’s real ability. Just about everyone looked pretty darn good on paper! That’s why I had to extrapolate what made each person unique via specific elements that weren’t based on coursework or grades (more on this later).
• The coding assignment was a huge asset in determining people’s real abilities. Some of the nicest assignments came from those with academically weaker performances. You could clearly see who the hackers and potential future computer science professors were. Without the assignment, the selection process would have been much harder, so I’m glad that it was something we required the applicants to do.
• With just a few exceptions, even good students seemed to struggle with relatively straightforward algorithmic questions, more than any other type of question. Sample questions included: What’s a Red-Black Tree and what would you use it for? Can you explain the P versus NP problem to me? (Note that these were rather open-ended questions, which I would generally follow up with more specific questions to assess the applicants’ theoretical backgrounds — as well as their way of thinking about these kinds of problems.)
• Most students didn’t know much about programming in the real world. In particular, they didn’t seem to be very up-to-date, most having never heard of things like SVN, GIT, MVC, ORM, Agile programming, or NoSQL.
• In general, the qualifications listed on the resumes we saw were greatly exaggerated by mediocre candidates, and somewhat downplayed by the great ones. (It looked like some form of Dunning–Kruger effect was at work.)
• Some candidates, taking advantage of the long distance telephone interview, tried to Google their answers and I could literally hear them typing as I presented them with questions that they weren’t familiar with. Replies such as, “Hmmm…well…”, followed by a 20 second pause and then the all but cut and paste Wikipedia definition. This was very easy to spot and didn’t end up boding well for those candidates who opted for this less than honest route.
• Recruiting is hard. It takes a lot of time and energy; rational decisions are challenging to make because in most cases you really are comparing apple to oranges.

What made a resume stick out to me

• Open Source contributions (a GitHub link would immediately arouse my interest in that candidate).
• A concise but detailed description of practical projects that had been implemented by the student for companies outside of their coursework (whether on the side or through internships).
• Social media involvement in the programming community. Did they have a StackOverflow profile? A Twitter account related to programming? Perhaps a a blog dedicated to the subject? While these points alone certainly don’t mean someone is a good programmer, they are a decent indicator that a person is at least passionate about the subject. Attendance of industry conferences (which some had) was also a strong indicator of interest in the field.
• Knowledge of unusual programming languages. Virtually everyone had Java on their resume, however that alone wasn’t good enough to catch my eye as an interviewer. (Heck, even Python is starting to be pretty common.) When candidates claimed knowledge of Haskell, Scala, Clojure, OCaml, Scheme, Factor, Io, J, etc… that definitely grabbed my attention. Again, this is no guarantee that someone is a good programmer, but chances are that they have an above average interest in our profession or have attended a university where these languages were taught (both positive signs).

While I’m not sure what you’ll get out of this article, I thought it was worth sharing as I found the whole process described above to be a fascinating one. Perhaps if you’re a student in a similar position you’ll find tips on what to do when applying for an internship with a company such as IBM. If you’ve ever found yourself in a similar interviewer’s position, you’ll likely find numerous relatable points in this post.

One final note: if you are curious, here’s Henrique and Marius at our first team party (after a few drinks):

No related posts.

An unwelcome surprise

If you don’t check yours regularly, you should (my version of Google Apps doesn’t have this feature though). In fact, tonight during a routine check, I discovered an unwelcome surprise: an entry that didn’t belong. The following screenshot shows the recent activity on my account (with some information blanked out):

See that US, IMAP line? That wasn’t me. So did someone manage to access my account? Or was it a web application that I authorized? Before panicking, I decided to look into whatever information I could gather about that IP.

It turns out that it’s the IP of a server hosted by Slicehost (RackSpace), but I couldn’t find any website running on that IP address (173.203.211.51). To make things more interesting, I found two people (one German, one Japanese) complaining online about the same IP address and IMAP access to their Gmail accounts.

Was my account hacked into? I have a hard time believing that someone actually managed to login by guessing my password which was as secure as a password can be. I haven’t used my laptop on an unsecured WiFi. I use a Mac and am very cautious about what I install, so I doubt I have a keylogger installed or anything of that nature. Using 1Password I’m even immune to the so-called “tab napping” attacks.

Possible culprits

Assuming that this is not a misunderstanding and some SaaS application I authorized is not in fact using that server to perform a legitimate action, I think it’s likely that someone managed to get in through a vulnerability or backdoor in one such application.

I’m not pointing fingers here, nor accusing anyone, but it is interesting to find such an occurence happening so shortly after granting the aforementioned authorizations. The websites I granted access to were:

• Zoho Discussions (24 hours before the suspected intrusion happened)
• Trendly (3 days before the intrusion)
• Etacts (a few weeks before the intrusion)

It’s worth mentioning that in the past Etacts had scared the crap out of me with their American IP showing up in the recent activity list. However a lookup has always shown the questionable IP to belong to them.

Do any of these services intentionally use the server with IP 173.203.211.51? Since I’m not the only one who suspects a violation from this IP, it would be interesting to hear what Slicehost has to say about it? Perhaps they know if it’s a legitimate or illegitimate use of their server.

How to deal with an email intrusion

The perception of being intruded upon, whether it’s real or just a scare, is definitely not pleasant. Just in case the same happens to you, here is what I did to deal with the situation:

• I verified that there were no messages sent on my behalf.
• I checked that there weren’t any new filters that would forward emails to a possible malicious user.
• I verified that there weren’t any forwards and ensured that forwarding was disabled.
• POP3 was already disabled, and I have now disabled IMAP as well.
• I revoked access to my Google account for all listed web applications.
• I changed my password to another humongous one on a different computer, with a brand new installation of Linux, directly wired to my DSL modem (bypassing the whole wireless infrastructure I set up at home).
• I will, soon enough, format my Mac (I’ve been planning a DBAN wipe, plus a brand new installation for a while either way).
• I will continue to monitor my account activity.

This is the kind of information I felt necessary to share even if this turns out to be a false alarm. I highly suggest that you keep an eye on your Gmail account activity and if you find something suspicious, act accordingly.

UPDATE (June 17, 2010): Please read my follow up post.

No related posts.

We start with setting up REE (x64), using the .deb file provided by Phusion:

wget http://rubyforge.org/frs/download.php/66163/ruby-enterprise_1.8.7-2009.10_amd64.deb
sudo dpkg -i ruby-enterprise_1.8.7-2009.10_amd64.deb
ruby -v

In output you should see “ruby 1.8.7 (2009-06-12 patchlevel 174)…” or similar. If this is the case, good; while you are there, update RubyGems and the installed gems:

sudo gem update --system
sudo gem update

Next, you’ll need to install nginx, which is a really fast web server. The Phusion team has made it very easy to install, but if you simply follow most instructions found elsewhere, you’ll get the following error:

checking for system md library ... not found
checking for system md5 library ... not found
checking for OpenSSL md5 crypto library ... not found

./configure: error: the HTTP cache module requires md5 functions
from OpenSSL library.  You can either disable the module by using
--without-http-cache option, or install the OpenSSL library in the
system,
or build the OpenSSL library statically from the source with nginx by
using
--with-http_ssl_module --with-openssl=
 options.

Instead, we are going to install libssl-dev first and then nginx and its Passenger module:

sudo aptitude install libssl-dev
sudo passenger-install-nginx-module

Follow the prompt and accept all the defaults (when prompted to chose between 1 and 2, pick 1).

Before I proceed with the configuration, I like to create an init script and have it boot at startup (the script itself is adapted from one provided by the excellent articles at slicehost.com):

sudo vim /etc/init.d/nginx

The content of which needs to be:

#! /bin/sh

### BEGIN INIT INFO
# Provides:          nginx
# Required-Start:    $all
# Required-Stop:     $all
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: starts the nginx web server
# Description:       starts nginx using start-stop-daemon
### END INIT INFO

PATH=/opt/nginx/sbin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=/opt/nginx/sbin/nginx
NAME=nginx
DESC=nginx

test -x $DAEMON || exit 0

# Include nginx defaults if available
if [ -f /etc/default/nginx ] ; then
    . /etc/default/nginx
fi

set -e

. /lib/lsb/init-functions

case "$1" in
  start)
    echo -n "Starting $DESC: "
    start-stop-daemon --start --quiet --pidfile /opt/nginx/logs/$NAME.pid \
        --exec $DAEMON -- $DAEMON_OPTS || true
    echo "$NAME."
    ;;
  stop)
    echo -n "Stopping $DESC: "
    start-stop-daemon --stop --quiet --pidfile /opt/nginx/logs/$NAME.pid \
        --exec $DAEMON || true
    echo "$NAME."
    ;;
  restart|force-reload)
    echo -n "Restarting $DESC: "
    start-stop-daemon --stop --quiet --pidfile \
        /opt/nginx/logs/$NAME.pid --exec $DAEMON || true
    sleep 1
    start-stop-daemon --start --quiet --pidfile \
        /opt/nginx/logs/$NAME.pid --exec $DAEMON -- $DAEMON_OPTS || true
    echo "$NAME."
    ;;
  reload)
      echo -n "Reloading $DESC configuration: "
      start-stop-daemon --stop --signal HUP --quiet --pidfile /opt/nginx/logs/$NAME.pid \
          --exec $DAEMON || true
      echo "$NAME."
      ;;
  status)
      status_of_proc -p /opt/nginx/logs/$NAME.pid "$DAEMON" nginx && exit 0 || exit $?
      ;;
  *)
    N=/etc/init.d/$NAME
    echo "Usage: $N {start|stop|restart|reload|force-reload|status}" >&2
    exit 1
    ;;
esac

exit 0

Change its permission and have it startup at boot:

sudo chmod +x /etc/init.d/nginx
sudo /usr/sbin/update-rc.d -f nginx defaults

From now on, you’ll be able to start, stop and restart nginx with it. Start the server as follows:

sudo /etc/init.d/nginx start

Heading over to your server IP with your browser, you should see “Welcome to nginx!”. If you do, great, we can move on with the configuration of nginx for your Rails app.

Edit nginx’ configuration file:

sudo vim /opt/nginx/conf/nginx.conf

Adding a server section within the http section, as follows:

    server {
        listen 80;
        server_name example.com;
        root /somewhere/my_rails_app/public;
        passenger_enabled on;
        rails_spawn_method smart;
    }

The server name can also be a subdomain if you wish (e.g., blog.example.com). It’s important that you point the root to your Rails’ app public directory.

The rails_spawn_method directive is very efficient, allowing Passenger to consume less memory per process and speed up the spawning process, whenever your Rails application is not affected by its limitations (for a discussion about this you can read the proper section in the official guide).

If you have lots of RAM (e.g., more than 512 MB) on your server, you may want to consider increasing you maximum pool size, with the directive passenger_max_pool_size from its default size of 6. Conversely, if you want to limit the number of processes running at any time and consume less memory on a small VPS (e.g., 128 to 256MB), you can decrease that number down to 2 (or something in that range). (Always test a bunch of configurations to find one that works for you). You can read more about this directive, in the official guide.

While you are modifying nginx’ configuration, you may also want to increase the worker processes (e.g., to 4, on a typical VPS) and add a few more tweaks (such as enabling gzip compression):

# ...
http {
    passenger_root /usr/local/lib/ruby/gems/1.8/gems/passenger-2.2.5;
    passenger_ruby /usr/local/bin/ruby;

    include       mime.types;
    default_type  application/octet-stream;

    access_log  logs/access.log;

    sendfile        on;
    keepalive_timeout  65;
    tcp_nodelay on;

    gzip on;
    gzip_comp_level 2;
    gzip_proxied any;   

    server {
    #...

When you are happy with the changes, save the file, and restart nginx:

sudo /etc/init.d/nginx restart

If you wish to restart Passenger in the future, without having to restart the whole web server, you can simply run the following command:

touch /somewhere/my_rails_app/tmp/restart.txt

Passenger also provides a few handy monitoring tools. Check them out:

sudo passenger-status
sudo passenger-memory-stats

That’s it, you are ready to go! I hope that you find these few notes useful.

No related posts.

The following steps are required to obtain syntax highlighting for your code:

1. Create a new wave and add the Syntaxy robot to your wave. Use the wave address: kasyntaxy@appspot.com.
2. Reply to your first message or within it, thereby creating a reply (called “blip” in Google lingo).
3. Specify your code’s language, prefixing the name with a hash and exclamation mark, like #!python or #!ruby.

At this point, as you type the code in your blip it will be highlighted by the Syntaxy bot as shown in the picture below:

More advanced automatic syntax highlighting bots will probably appear as Google Wave progresses, but this one should do the trick for now. On a side note, if you copy and paste code from XCode, the code formatting will be kept in your waves and blips without the need for bots.

No related posts.

The most important new feature is the presence of a compiler. That’s right, thanks to this release, Ruby code can now become highly optimized executable code. How awesome is that? I can sense that you’re pumped by this news, so why not head over to MacRuby.com and download the installation file for yourself? After you’ve done that, the next thing you’re going to want to do is run a small test like the following:

$ macrubyc world_domination.rb -o world_domination
Can't locate program `llc'

Oh noes! llc is a tool that ships with the LLVM (upon which MacRuby is built), however it’s not included with MacRuby’s installer (it will be in the future). But fear not my friends, there is a solution:

$ svn co -r 82747 https://llvm.org/svn/llvm-project/llvm/trunk llvm-trunk
$ cd llvm-trunk
$ ./configure
$ UNIVERSAL=1 UNIVERSAL_ARCH="i386 x86_64" ENABLE_OPTIMIZED=1 make -j2
$ sudo env UNIVERSAL=1 UNIVERSAL_ARCH="i386 x86_64" ENABLE_OPTIMIZED=1 make install

If your machine does not have 2 cores, remove the -j2 option from the fourth line or adjust the number accordingly.

The compilation phase may take a couple of centuries, depending on your machine’s speed, but it should eventually build the LLVM. llc will be placed in your PATH, and you’ll finally be able to compile Ruby code and obtain an executable to help you carry out your world domination plans.

$ macrubyc world_domination.rb -o world_domination
$ ./world_domination
MUAHAHAHAHA!

No related posts.

Generally speaking, for performance reasons, it’s advised that you have two different webservers serving your dynamic requests and static files. In practice, for smaller sites, people often opt to simply use one webserver. In this article, I’ll discuss how to serve the static files within your Django project, through Apache.

The first thing we need to do is distinguish between development and production mode. We can do so by simply specifying DEBUG = True (development), or DEBUG = False (production) within our settings.py file.

settings.py may include (among others) the following declarations:

# Absolute path to the project directory
BASE_PATH = os.path.dirname(os.path.abspath(__file__))

# Main URL for the project
BASE_URL = 'http://example.org'

DEBUG = False

# Absolute path to the directory that holds media
MEDIA_ROOT = '%s/media/' % BASE_PATH

# URL that handles the media served from MEDIA_ROOT
MEDIA_URL = '%s/site_media/' % BASE_URL

# URL prefix for admin media -- CSS, JavaScript and images.
ADMIN_MEDIA_PREFIX = "%sadmin/" % MEDIA_URL

*PATH constants indicate paths on your filesystem (e.g., /home/myuser/projects/myproject), while *URL constants indicate the actual URL needed to reach a given page or file.

Notice that it’s not unusual to have a /site_media URL that corresponds to a /media folder. In the example above, I opted to separate regular media files for the project from the standard ones that ship with Django for the admin section. To do this, all we have to do is create a symbolic link as follows:

ln -s /usr/lib/python2.5/site-packages/django/contrib/admin/media /path/to/myproject/media/admin

When you’re in development mode, and DEBUG = True, you want to let Django serve your static files. This can be done by adding the following snippet (or similar) to your urls.py:

if settings.DEBUG:
    urlpatterns += patterns('',
        (r'^site_media/(?P<path>.*)$', 'django.views.static.serve', {'document_root': settings.MEDIA_ROOT}),
    )

In production mode, the code contained within the if clause will not be executed as we’ve set DEBUG to False within settings.py.

From the Django side of things, we are good. We now need to instruct Apache. Within your virtual host file, you can specify something along the lines of:

<VirtualHost *:80>

  #...

  SetHandler python-program
  PythonHandler django.core.handlers.modpython
  SetEnv DJANGO_SETTINGS_MODULE myproject.settings
  PythonDebug On
  PythonAutoReload Off
  PythonPath "['/usr/lib/python2.5/site-packages/django', '/path/to/myproject'] + sys.path"

  #...

  Alias /site_media "/path/to/myproject/media"
  <Location "/site_media">
    SetHandler None
  </Location>
</VirtualHost>

The first group of declarations essentially tells Apache to use mod_python to handle any incoming requests. However, we don’t want Django to deal with static files, so the second group of declarations, aliases/maps the /site_media URL with the actual media directory on the server, and tells Apache to threat it as static content (with SetHandler None) bypassing de facto Django.

No related posts.

Using memoization in Ruby is very easy thanks to the memoize gem. The first step to getting started is therefore to install it:

$ sudo gem install memoize
Successfully installed memoize-1.2.3
1 gem installed
Installing ri documentation for memoize-1.2.3...
Installing RDoc documentation for memoize-1.2.3...

Now we can use the memoize method as illustrated in the example below:

require 'rubygems'
require 'memoize'
require 'benchmark'
include Memoize

def fib(n)
  return n if n < 2
  fib(n-1) + fib(n-2)
end

Benchmark.bm(15) do |b|
  b.report("Regular fib:") { fib(35) }
  b.report("Memoized fib:") { memoize(:fib); fib(35)}
end

In the first block we simply invoke fib(35), while in the second one we first invoke the method memoize(:fib) to memoize the method fib. Running this code on my machine prints the following:

                     user     system      total        real
Regular fib:    55.230000   0.160000  55.390000 ( 55.819205)
Memoized fib:    0.000000   0.000000   0.000000 (  0.001305)

We went from almost a minute of run time to an instantaneous execution. Optionally we could even pass a file location to the function memoize and this would use marshaling to dump and load the cached values on/from disk.

For Python we can write a simple decorator that behaves in a similar manner. In its simplest form it can be implemented as follows:

# memoize.py

def memoize(function):
    cache = {}
    def decorated_function(*args):
        try:
            return cache[args]
        except KeyError:
            val = function(*args)
            cache[args] = val
            return val
    return decorated_function

Or more efficiently:

# memoize.py

def memoize(function):
    cache = {}
    def decorated_function(*args):
        if args in cache:
            return cache[args]
        else:
            val = function(*args)
            cache[args] = val
            return val
    return decorated_function

When the memoized function has been invoked, we look in the cache to see if an entry for the given arguments already exist. If it does, we immediately return that value. If not, we call the function, cache the results and return its returning value.

Truth be told, the limit of this approach lies in the fact that since we are using a dictionary, only immutable objects can be used as keys. For example, we can use a tuple but are not allowed to have a list as a parameter. For the example within this article, this approach will suffice, but to take advantage of memoization when using arguments that are mutable, you may want to consider the approach described in this recipe.

We can now rewrite the Ruby example above in Python as follows:

import timeit
from memoize import memoize

def fib1(n):
    if n < 2:
        return n
    else:
        return fib1(n-1) + fib1(n-2)

@memoize
def fib2(n):
    if n < 2:
        return n
    else:
        return fib2(n-1) + fib2(n-2)	

t1 = timeit.Timer("fib1(35)", "from __main__ import fib1")
print t1.timeit(1)
t2 = timeit.Timer("fib2(35)", "from __main__ import fib2")
print t2.timeit(1)

Running this code on my machine prints the following:

9.32223105431
0.000314950942993

In Python 2.5′s case by employing memoization we went from more than nine seconds of run time to an instantaneous result.

Granted we don’t write Fibonacci applications for a living, but the benefits and principles behind these examples still stand and can be applied to everyday programming whenever the opportunity, and above all the need, arises.

No related posts.

This problem is a known Java bug (resolved in Java 6) that shows up on Linux distros where Compiz effects are enabled. For example, this problem manifests itself in recent Ubuntu releases, including 8.10, where Compiz is enabled by default.

There are a couple of easy ways to solve this problem though. The first is to temporary disable these effects during the installation and turn them back on when you’ve finished installing. In Ubuntu, you can do this by clicking on the Appearance menu, Visual Effects tab and then selecting None. The second method is to run export AWT_TOOLKIT=MToolkit, before running sudo ./db2setup.

A new setup is in the works to solve this issue, but for the time being, you can use the workarounds above to install DB2 Express-C on Linux.

Possibly related posts:

1. Installing DB2 9.5 on Ubuntu 7.10
2. Guide to setting up the IBM Ruby and Python drivers for DB2 on Linux (32 or 64 bit)
3. DB2 Express-C 9.5 is available for download

Pygments is a Python library but ships as a command line tool as well. However, switching between TextMate and the command line is not as convenient as I’d like. So on the weekend I pulled out my big sharp razor and started yak shaving. The result of that brief session is a hack that delivers the integration of TextMate and Pygments, so that code can be easily converted to HTML in order to beautifully present it.

First, let’s see how I use it. When I select a snippet of Ruby code in TextMate and press ⌃⌥1 a snippet of code is transformed into the proper HTML. ⌃⌥2 is for Python snippets, ⌃⌥3 for any other language, and ⌃⌥4 for any language as well but with the option of adding line numbers. In practice, this means that I use 1 and 2 most of the time and these shortcuts are easy enough to remember. Note that this is not necessarily the best arrangement, but it works well for me. I could, if so inclined, associate all 4 commands to the same shortcut and be prompted by a menu every time this combination is pressed, obtaining something along the lines of the image shown below:

Should I ever forget these 4 shortcuts, I can take a quick look at the Text bundle menu shown below. I placed these commands under the Text menu, since they are globally available for textual formats, whether I’m composing HTML, Textile, Markdown or ReST; but this is entirely arbitrary and I suspect that many would consider the HTML menu instead or place a “Convert to HTML” entry in the menu of the specific language.

Ruby and Python deserve their own command because they are the languages whose code I publish the most, but pressing ⌃⌥3 (or 4) prompts a long list of languages to choose from as shown below (the image is cut to reduce its length):

The following are a series of steps that you can take to reproduce the same results as mine. The HTML required to present the code nicely in this section was generated from within TextMate. In other words, I’m eating my own dog food.

Step 1: If you haven’t done so already, install Pygments. You can get it from the official site.

Step 2: Within TextMate click on the menu entry: Bundles -> Bundle Editor -> Show Bundle Editor and click on the triangle to open up Text in the left pane.

Step 3: Click on the +- button in the lower left corner of the window and select New Command, then name the command Pygmentize Ruby (assuming that you want a command for Ruby).

Step 4: Ensure that each option for Save, Input, Output and Activation are the same as shown below (click to enlarge):

Step 5: Fill the Command(s) text area with the following code:

#!/usr/bin/env python

import os
import sys
from pygments import highlight
from pygments.lexers import RubyLexer
from pygments.formatters import HtmlFormatter

try:
    code = os.environ['TM_SELECTED_TEXT']
except KeyError:
    sys.exit()

formatter = HtmlFormatter()
print highlight(code, RubyLexer(), formatter)

Step 6: Repeat the process for Pygmentize Python, Pygmentize… and Pygmentize with line numbers… but select a different Activation key equivalent (replace 1 with 2, 3 and 4, respectively).

The command code for Pygmentize Python is as follows:

#!/usr/bin/env python

import os
import sys
from pygments import highlight
from pygments.lexers import PythonLexer
from pygments.formatters import HtmlFormatter

try:
    code = os.environ['TM_SELECTED_TEXT']
except KeyError:
    sys.exit()

formatter = HtmlFormatter()
print highlight(code, PythonLexer(), formatter)

For Pygmentize… use the following:

#!/usr/bin/env python

import os
import sys
from commands import getoutput
from pygments import highlight
from pygments.lexers import get_all_lexers, get_lexer_by_name
from pygments.formatters import HtmlFormatter

try:
    code = os.environ['TM_SELECTED_TEXT']
except KeyError:
    sys.exit()

available_languages = ", ".join(sorted('"'+lex[1][0]+'"' for lex in get_all_lexers()))
chosen_language = getoutput("""echo $(osascript <<'AS'
    tell app "TextMate"
        activate
        choose from list { %(languages)s } \
            with title "Pick a language" \
            with prompt "Select a language"
    end tell
AS)""" % {'languages':available_languages})
os.system("osascript -e 'tell app ""TextMate"" to activate' &>/dev/null &")

lexer = get_lexer_by_name(chosen_language.lower())
formatter = HtmlFormatter() # linenos=False
print highlight(code, lexer, formatter)

And finally for Pygmentize with line numbers… use the almost identical script below:

#!/usr/bin/env python

import os
import sys
from commands import getoutput
from pygments import highlight
from pygments.lexers import get_all_lexers, get_lexer_by_name
from pygments.formatters import HtmlFormatter

try:
    code = os.environ['TM_SELECTED_TEXT']
except KeyError:
    sys.exit()

available_languages = ", ".join(sorted('"'+lex[1][0]+'"' for lex in get_all_lexers()))
chosen_language = getoutput("""echo $(osascript <<'AS'
    tell app "TextMate"
        activate
        choose from list { %(languages)s } \
            with title "Pick a language" \
            with prompt "Select a language"
    end tell
AS)""" % {'languages':available_languages})
os.system("osascript -e 'tell app ""TextMate"" to activate' &>/dev/null &")

lexer = get_lexer_by_name(chosen_language.lower())
formatter = HtmlFormatter(linenos=True)
print highlight(code, lexer, formatter)

Step 7: Click on Text and by dragging and dropping arrange the menu to include the Pygmentize commands as shown below (click to enlarge):

Step 8: At this point everything should work, whether you invoke the commands through a keyboard shortcut or through the Text menu. However, you will need to upload and include a Pygments stylesheet from within your site. To generate a stylesheet run the following from the command line:

pygmentize -S default -f html > pygmentize.css

In the above command, default is the name of the style. For example, the Python code you see in this article is styled with the style pastie (because I globally adopted that stylesheet for this site). For a comparison of the available styles check out this demo page.

Step 9: ????

Step 10: Profit!

I hope these hacked together commands can be useful to others. Feel free to customize them and improve upon them as it suits your needs.

UPDATE: I made a Pygments TextMate Bundle out of this.

Possibly related posts:

1. TextMate is the king of Rails editors
2. Ruby and Rails books, Textmate and FastRi
3. How to install Django with MySQL on Mac OS X