Michele Campeotto

Enhanced buftabs Vim Plugin

2007-03-28T10:31:18-07:00

After a couple of days using my bufpos vim plugin together with buftabs, I realized I didn’t need the buffer numbers in the status line (I can always get them with :ls), but their position number would have been very useful.

So here is my modified version with these three changes:

the tab numbers indicate the the number you have press to get there instead of the buffer number
improved autocmd settings to better synchronize the ! modified flag
different filename shortening mode, now it is displayed with a path relative to the current or home directory (don’t set g:buftabs_only_basename to get that)

I have contacted the buftabs author and the last two will be in the next buftabs release too.

Tabs in Vim and My First Plugin

2007-03-26T00:25:47-07:00

One of the most talked about features of Vim7 are tabs, but I don’t like them very much, I think they should have been given a different name. They could have been called layouts, for example, because they are very different from what most people expect and much more similar to Eclipse’s perspectives or NetBeans workspaces than to Firefox tabs.

I find buffers, which have been in Vim since pretty much forever, are a very convenient way to edit multiple files. You just have to tune them a bit.

First, you absolutely have to set the hidden option, so you can switch between buffers without being forced to save them, and then you need some key mappings:

set hidden
map <C-TAB> :bnext!<CR>
map <C-S-TAB> :bprev!<CR>
map <C-\> :b#<CR>

Use Ctrl-Tab and Ctrl-Shift-Tab to navigate through the list of open buffers and Ctrl-\ to quickly toggle between two open files.

After using this setup for quite some time, about a week ago I found buftabs, a simple plugin that displays the open buffers in the status line. I like simple plugins, my rule is that they have to be useful without me having to actually learn to use them or even remember they are there.

set laststatus=2
let g:buftabs_in_statusline=1

I then added two more mappings to navigate through buffers, to better match the visual representation buftabs provides.

map <C-b> :bprev!<CR>
map <C-n> :bnext!<CR>

With these switching buffers is even easier, as you have a visual indication of which buffer you are going to activate.

Just one last piece was missing from this picture: most tabs implementations allow you to directly activate a tab by pressing the Alt key and a number, like Firefox, for example.

So here comes my first Vim script ever: bufpos is a very simple script that maps Alt-number keys to activate buffers.

Note that you don’t have to use the buffer number buftabs puts beside the file name, but the position in the buffers list.

Splicing your feeds with Yahoo! Pipes

2007-03-01T09:42:24-08:00

One of the services that made me subscribe to FeedBurner when it has been launched, was the ability to splice my Flickr pictures and my del.icio.us bookmarks together with my blog feed. The problem with doing this with FeedBurner is that it is somewhat limited: I can’t splice together arbitrary feeds, just the ones from the supported services.

The easiest solution I could come up with, was using a personal installation of Planet where I’d subscribe my feeds and then take just resulting feed from there, but I never managed to do this, too much grunt work to do on my part: it wasn’t fun.

Then, Yahoo! launched Pipes. Pipes is a very nice service which allows you to play with feeds and munge them together by applying different kinds of filters. Pipes are fun to play with you drag and drop the building blocks, connect them together, add some magic and you have your new feed.

Some days ago, Gina Trapani posted an article on lifehacker explaining how to build your master feed, collecting all the feeds you produce on various blogs and services together in a single feed. She also has an example on how to inspect the feed contents to filter some items from the resulting feed.

In her article, Gina says she’d like to add a prefix for the feed source to differentiate the item titles. Here I have a demonstration of the power of Yahoo!’s new toy: you can do that, by using the Regex operator module to change the contents of an item’s element.

The steps to build a Pipe like this are:

use a different Fetch source for each of your feeds
filter the elements you don’t want
apply the Regex operator to the title to replace ”^” with ”Source:”, which is just Regex-fu for “put the source name in front of the title” (you’ll have to put the actual name you want for the source instead of “Source”, see the example pipe I created). (updated with hint by muczachan)
put all the resulting feeds in a Union operator
sort the Union output feed

Optionally, you can limit the number of items in the resulting feed by using the Truncate operator. Also, should you have more feeds than the five input sockets of the Union module provides, you can add more Union modules and then combine them with another one.

Feel free to clone the pipe I created and adapt it to your own feeds.

FlickrUploadr is back

2007-02-26T06:00:23-08:00

Eighteen months later, Eric Weigle sent me a new version of FlickrUploadr wich supports Yahoo!’s authentication scheme, which is now required even for first-time Flickr users.

Eric merged my code with Cameron Mallory’s great authentication support and built this new version. Thanks to the new authentication scheme, FlickrUploadr doesn’t save your password on your disk anymore, so you can now remove the ~/.uploadr file.

Thanks Eric and Cameron for the very nice work.

Download FlickrUploadr 1.0.

Scala

2007-02-23T14:47:41-08:00

I recently learned about Scala, a language for the JVM which tries to smoothly integrate object oriented and functional programming features.

I find it particularly interesting because of two reasons: first it is integrated with the Java platform and thus can use all the Java code already available. Second, it can be used almost as a Java evolution where you can gradually add functional concepts and more advanced features of the type system.

Scala is a static language, and lately the whole world is excited about dynamic languages, so this might seem a bit backwards, but I think sane static languages have their place in the world. And Scala has some very nice features (pattern matching on objects, flexible syntax) to make it appealing to me. I’d like to try to use it at work, integrating it with the bulk of Java code we already have.

To experiment a bit with the language I tried translating some examples from Haskell. The result is kinda pointless and probably not a good example of Scala programming, but it helped me get a feeling of the language.

package test.sort

object QuickSort {

  def qsort1[A <% Ordered[A]](xs: List[A]): List[A] = xs match {
    case y :: ys => {
      val lt = for (val i <- ys; i < y) yield i;
      val gt = for (val i <- ys; i >= y) yield i;
      qsort1(lt) ::: List(y) ::: qsort1(gt)
    }
    case Nil => Nil
  }

  def qsort2[A <% Ordered[A]](xs: List[A]): List[A] = xs match {
    case Nil => Nil
    case z :: zs => {
      def part(z: A, zs: List[A], parts: Tuple3[List[A], List[A], List[A]]): Tuple3[List[A], List[A], List[A]] = zs match {
        case Nil => parts
        case y :: ys => {
          if (y > z)
            part(z, ys, {parts._1, parts._2, y :: parts._3})
          else if (y < z) 
            part(z, ys, {y :: parts._1, parts._2, parts._3})
          else 
            part(z, ys, {parts._1, y :: parts._2, parts._3})
        }
      }
      val parts = part(z, zs, Tuple3(Nil, List(z), Nil))
      qsort2(parts._1) ::: parts._2 ::: qsort2(parts._3)
    }
  }

  def qsort3[A <% Ordered[A]](xs: List[A]): List[A] = {
    def qsort3b(ys: List[A], acc: List[A]): List[A] = ys match {
      case Nil => acc
      case List(z) => z :: acc
      case z :: zs => {
        def part(ps: List[A], parts: Tuple3[List[A], List[A], List[A]]): List[A] = ps match {
          case Nil => qsort3b(parts._1, parts._2 ::: qsort3b(parts._3, acc))
          case z :: zs => {
            if (z > ys.head)
              part(zs, {parts._1, parts._2, z :: parts._3})
            else if (z < ys.head)
              part(zs, {z :: parts._1, parts._2, parts._3})
            else
              part(zs, {parts._1, z :: parts._2, parts._3})
          }
        }
        part(zs, {Nil, List(z), Nil})
      }
    }
    qsort3b(xs, Nil)
  }
}

A little Django feature nobody tells you about

2007-01-06T09:36:20-08:00

Recently i got involved in a new project which uses Django, so I started learning and using it. I won’t tell you here it merits as those have alread been described at lenght.

One of the features I like about Django are its pluggable applications: you can build a generic piece of code and that can easily be plugged in other’s sites to get some new functionality. Great examples of this are found in the django.contrib package, which include the already famous administrative interface, two comments systems, an authentication/authorization framework and more.

One problem you’ll soon find is that some of these are tied to be plugged at a fixed URL prefix. The auth system, for example, expects to be plugged in the /accounts/ directory and plugging it somewhere else leads to some more work for you. The easiest example is the @login_required decorator, which checks the user that is calling a view and, if it is not authenticated, it redirects to /accounts/login. If you have used a different URL prefix, you are forced to use the @user_passes_test decorator, which allows you to set the redirect URL.

Where is the problem? The problem is that those paths are explicitly hardocded in the views.

How to solve it? Dynamically build your URLs from your urlconf.

How do you do that? With django.core.urlresolvers.reverse()

That little boy helps you by giving you the URL path that would be called given a view and a set of parameters. Here is an example, suppose your urlconf has something like this:

urlpatterns = patterns('',
    (r'^/blog/(?P<year>\d{4})/(?P<month>\d{2})/(?P<day>\d{2})/(?P<slug>[-\w]+)/$',
        'dlog.blog.views.entry'),
)

you could create a function like this to get the URL of an entry:

    def get_absolute_url(self):
        return urlresolvers.reverse('dlog.blog.views.entry',
                kwargs={'year':self.pubdate.year,
                        'month':('%02d' % self.pubdate.month),
                        'day':('%02d' % self.pubdate.day),
                        'slug':self.slug})

when you then call an entry’s get_absolute_url() method, you’ll get the URL as urlconf expects it.

/blog/2007/01/06/your-slug-goes-here

I don’t know why this isn’t mentioned anywhere in the docs, I found it by hunting down the source code because I didn’t like hardcoding paths in my views.

I can understand it has some problems: it gives you only URLs relative to the root of the Django project, if you need an absolute URL or if you attached the site to a subdirectory of your domain, urlresolvers.reverse() is not enough, but I still think it should be advertised in the documentation.

One more thing, as everybody starting to use Django, I wrote a web log with it. But I haven’t replaced this one, I created a new one, but this time in Italian and that will be more personal and, hopefully, a real blog that I update it more often than monthly and I actually participate. So, if you can read Italian follow me on my new corner.

A tale of Pylons, Python and FastCGI on Dreamhost

2006-11-27T03:41:19-08:00

Pylons is a WSGI based Python Web Framework that tries to combine the best ideas from other existing frameworks and does so by glueing togheter existing projects and allowing to swap its components at will and easily extend its capabilites with other WSGI components.

I will explain here how I installed it and a demo application on Dreamhost and how to avoid the single problem I had.

This procedure isn’t specific to either Dreamhost or Pylons, it can be used anywhere and for any WSGI compliant application if you don’t have root access to install new modules or if you want to keep the system wide installation clean and add modules just for a single user.

The installation procedure is quite easy and mostly automated, start by running these commands from your home directory on the remote shell:

mkdir bin
wget -P bin http://peak.telecommunity.com/dist/virtual-python.py
python2.4 bin/virtual-python

It’s important that you use python2.4 here, not just python.

This command will create some directories and symlinks on your home directory that will result in you little private Python environment, where you have the power to install new packages at will. To make the illusion more real, you should then add ~/bin in front of your $PATH, so that you can just type python in the shell and the interpreter used will be your private one instead of the global one.

export PATH="~/bin:$PATH"    # add this to ~/.bash_profile
wget -P bin http://peak.telecommunity.com/dist/ez_setup.py
python bin/ez_setup.py

This will install the easy_install script that you will use to install Pylons and other Python modules you can find on the Cheese Shop:

easy_install Pylons

This will install the Pylons framework and all its dependencies. To test the installation we will use the QuickWiki demo application:

easy_install QuickWiki

This will install the application and some more dependencies. The next step is creating the configuration file for the application:

paster make-config QuickWiki wiki.ini

In this file you only have to change the database URI, for this test we will use SQLite:

sqlalchemy.dburi = sqlite:///quickwiki.db

And setup the application to create the database:

paster setup-app wiki.ini

Then we need a script to start the application. Pylons, as every WSGI application can be deployed in a number of different ways, but the only one you can use on Dreamhost is FastCGI. At this point, every tutorial around the web will tell you to use flup and then there will be pain and hair pulling because you won’t understand why it’s not working (unless you ask Allan Saddi to check your setup, that is. Thank you Allan!).

The solution is to use the supposed to be obsolete fcgi.py script, so let’s install it:

wget -P lib/python2.4/site-packages http://svn.saddi.com/py-lib/trunk/fcgi.py

We said we needed a script, so put this in a file named server.fcgi in your web directory and make it executable:

#!/home/username/bin/python

from paste.deploy import loadapp
from fcgi import WSGIServer

app = loadapp('config:/home/username/www.yourdomain.net/wiki.ini')
server = WSGIServer(app)
server.run()

You will need to correct the paths here, as we need them to be absolute.

Now when you point at this file in a web browser you should see the QuickWiki FrontPage.

The problem with flup (as found by Allan itself) is that it takes too long to start and it seems that FastCGI on Dreamhost will wait for a maximum of 3 seconds. fcgi.py instead is simpler (doesn’t do thread pooling for example) and therefore faster to start. This means that when the server is under heavy load there could still be problems, but it has been pretty reliable.

The best solution to this problem would be SCGI support by Dreamhost, if you already are a customer, go vote for it!

Ruby and Python: perspectives

2006-11-28T03:11:55-08:00

I just realized something interesting.

In Ruby you mix in modules that add methods to objects that implement interfaces.

In Python you have functions that you use on objects that implement interfaces.

One easy example are enumerables/iterables: in Ruby, an object is enumerable if it implements the each method. The object can then mix in Enumerable to gain some methods that you can use:

f = File.new(".bashrc", "r")
lines = f.find_all { |l| l =~ /^[^#]/ }
# or lines = f.grep(/^[^#]/)

In Python, an object is iterable if it implements the __iter__ method, and the language “knows” how to use the iterators:

f = file(".bashrc", "r")
lines = [ l for l in f if not l.startswith("#") ]
# or lines = filter(lambda l: not l.startswith("#"), f)

other examples are any and all, which incidentally are what started the discussion with Francesco about this:

In Ruby, the any? method is added to every enumerable object that mixes in Enumerable:

lines.any? { |l| l =~ /^#/ }

In Python, any() is a built-in function (introduced in 2.5) which knows how to use any sequence:

any(l.startswith("#") for l in lines)

So Ruby works from the inside, and Python from the outside of objects. I think therefore that the next comparison between the two languages should not be side-by-side, but inside-and-out.

How I read and backup my mail

2006-11-07T12:50:44-08:00

I was going to answer Stuart’s question to the Lazyweb in a quick comment, but I figured my email set up, while essentially not really special, is a bit peculiar and might be interesting to somebody out there.

I have all my personal email on Gmail, but I also download it locally to keep a backup, just in case. The problem is that if you read your mail with Thunderbird, it ends up inside a directory with a funny name which in turn contains a funny mix of files of which you don’t know the purpose, so the backup (and the restore) is a bit unpractical.

The solution turned out to be quite easy: you retrieve your email and with some magic symlinks you make Thunderbird read that. The only limitations to this are that Thunderbird only supports mbox mailboxes and that it has to update its indexes every time it starts.

My final set up is that I can retrieve, read and send email with both mutt and Thunderbird and the mail is in plain mbox files that I can easily rsync around. Here’s how I did it.

mutt downloads the mail and puts it in ~/Mail:

set pop_host = pops://micampe@pop.gmail.com:995
set pop_last = yes

set folder = ~/Mail
set spoolfile = +spool
set postponed = +postponed
set mbox = +inbox
set record = +inbox

set sendmail="~/.mutt/ssmtp"

You can see I also keep sent and received mail together, to emulate Gmail’s conversations, which I find very convenient.

To send mail (and this is my answer to Stuart), I use ssmtp, a very simple SMTP agent which is also flexible and easy to configure. It just connects to an external SMTP server and forwards my email to it. No queuing, no forwards, no nothing it just does that and here’s how I set it up:

mailhub=smtp.gmail.com:465
rewriteDomain=micampe.it
FromLineOverride=YES
UseTLS=YES
AuthUser=micampe@gmail.com

This is saved in ~/.mutt/ssmtp.conf and is used by the script ~/.mutt/ssmtp which mutt is using to send mail:

#!/bin/sh
/usr/sbin/ssmtp -C ~/.mutt/ssmtp.conf $@

One nice thing about ssmtp is that it’s just a command line program that you run when you want to send a mail, you don’t need to have a daemon running.

Now I just have configured mutt to read my mail from Gmail, “what’s the deal?” you say, “this is easy.” Well, the next step is where I symlink mutt’s inbox with Thunderbird’s:

$ cd ~/.mozilla-thunderbird/*.default/Mail/Local\ Folders/
$ rm Inbox
$ ln -s ~/Mail/inbox Inbox

Now mutt and Thunderbird have access to the same mail messages, and I can use which one I like best in a given moment.

Vim Tango color scheme

2006-11-28T04:12:01-08:00

Things you do at the airport while waiting for the cute girl to call the boarding…

Finding that a Tango color scheme for my terminal was a nice idea, I made one for my Vim too.

To use the Vim Tango color scheme you have to place the tango.vim file in the ~/.vim/colors/ directory and colorscheme tango in your ~/.vimrc.