So here is a brief description of how to do it:

1. Install the X-Code developer tools (for GCC, make and other build tools) from your Snow Leopard installation DvD.
2. Install the X11 Window System from your Snow Leopard installation DvD.
3. Run ‘Software Update‘ from the apple menu on your Mac to get the latest X-Code updates.
4. Download the latest MacPorts installer (.dmg file extension) for Snow Leopard from here: http://distfiles.macports.org/MacPorts/.
5. Mount the installer image file (.dmg) and run the contained MacPorts installer (.pkg).
6. Once installation is complete open a terminal window from Applications->Utilities->Terminal.
7. Type ‘port‘ at the terminal then press enter to run MacPorts.  You should see output like the following if it installed correctly:
   MacPorts 1.8.1
   Entering interactive mode… (“help” for help, “quit” to quit)
   Then type ‘quit‘ then press enter to exit port’s interactive mode.
8. Type ‘sudo port selfupdate‘ and press enter to update MacPorts to the latest version.  You will be asked to enter the administrators password before continuing.  Depending on how new the version you downloaded is, MacPorts may do some upgrading.
9. Once the update is finished type ‘sudo port install py26-matplotlib‘ and press enter.  This will attempt to install the latest version of matplotlib for Python version 2.6.*.   You may be asked to enter the administrators password before continuing.  MacPorts will now download, configure, build and stage the dependencies needed to build the latest matplotlib for Python 2.6.  This took at least thirty minutes on my iMac and involved lots and lots of scrolling text output from the build process.
10. Next we need to switch our environment to use version 2.6.* of Python that MacPorts just built and installed with matplotlib.  To do this run the following two commands, note you may be asked to enter the administrators password before continuing:
    1. ‘sudo port install python_select‘ and hit enter.
    2. ‘sudo python_select python26‘ and hit enter.
11. To test this all worked type the following: ‘python -V’ and hit enter.  You should see output like ‘Python 2.6.4‘ which should match the version of python MacPorts built and installed.
12. Finally to test if matplotlib was installed correctly do the following:
    1. Type ‘python‘ and hit enter to enter the python interactive shell.
    2. Type ‘import matplotlib‘ and hit enter, this will import the matplotlib module.  There should be no output if this works.
    3. Type ‘print matplotlib.__version__‘ and hit enter. This will print the version of matplotlib that is installed, you should see output like ‘0.99.1.1‘.
    4. Type ‘exit()‘ to quit the python interactive shell.

This is a very convenient pairing as SQLite is an excellent lightweight SQL implementation that I find very useful for a variety of tasks e.g. data mining.  Or any task involving manipulating complex data sets where I’d otherwise end up resorting to using a full blown SQL server like MySQL.

Here is a simple example of using SQLite in Python using it’s built-in sqlite3 module:

import sqlite3

# craete a connection
con = sqlite3.connect('test.db')

# create a cursor
cur = con.cursor()

# create a test table
cur.execute( "CREATE TABLE testTable (myKey INT, myValue INT)" )

# insert some data
for i in range(0,10):
 cur.execute( "INSERT INTO testTable VALUES ( %d, %d )"%(i,i*i) )

# select the data
for row in cur.execute( "SELECT * FROM testTable" ):
 print row

# destroy (drop) our test table
cur.execute( "DROP TABLE testTable" )

# close the connection
con.close()

As you can see Python makes handling SQLite (a C language library) much easier, less error prone, and the resulting code much more compact than SQLite’s native C.

The availability of MVC oriented web frameworks for Python (Django) and Ruby (Ruby on Rails) was not something I had considered when making my earlier decision about which of these two languages to put time into learning.  However now that the idea of writing a new version of this site in one of these new fangled MVC/ORM frameworks has occurred to me, I’d like to reconsider my earlier decision.  I’ve done some Google searches on ‘Django or Ruby on Rails’ and have been reading through the results.  One of the more interesting blog posts I found on Django, Rails and php (here) has lead me on to the videos of the ‘Snakes and Rubies’ presentations which are very informative and well worth watching (they can be found here).

So far after watching the Django presentation I must admit I’m loving a lot of what was demonstrated: automatic administration page generation, built in caching, URL pattern matching and templates which separate content and logic/code sounds ideal.  The automatic generation of an administration interface sounds especially nice as writing an decent administration interface is very time consuming to do correctly.  And these interfaces are not something the end users will generally ever see so it can fell like a lot of effort for a feature that is never appreciated by the general population only by the administrators.  The template system sounds excellent as well as it means graphic/web designers can handle the design of the site without requiring programming knowledge or support.

I’ve now watched the Ruby presentation too and I have to admit it did not grab me as much as the Django presentation did.  Beautiful code, which seemed to be the main selling point of the presentation is a wonderful thing.  However features like administration interface generation, caching and templates are more attractive to me than being able to use fewer lines of code to do things.

To digress for a moment, I think that my lack of excitement at the concept of beautiful code as it was presented in the video, could be in part to me being mainly a C/C++ programmer: so beautiful code in the sense of code that does a lot of work in a few lines of source code is not something you see very often in C/C++.  In fact in a lot of cases that particular brand of beautiful code is something you would be down right suspicious of in C/C++ but that is perhaps more due to the nonrestrictive nature of C/C++: its lack of hand holding or built in safety as a language.  This lack of safety perhaps drives C/C++ programmers to be more obsessive about understanding what exactly their source code does under the hood to avoid unpleasant surprises later.  This encourages a preference for easy to read and comprehend source code and perhaps promotes suspicion of ‘voodoo’ code that does allot of work in a few lines of usually harder to read code.  In short beautiful code is a worthy goal but something I would personally be suspicious of but that is probably more due to my personal C/C++ baggage than any fault in Ruby.

Now back to Ruby on Rails or Django.  Another thing which I had not really considered in my earlier post was which language had the best range of high quality libraries available.  I had assumed that both languages would have a similar range of libraries available but so far my investigations seem to be pointing to Python as having more.  Ruby does not seem to have as many available libraries, unless of course I’m using the wrong keywords when searching the ruby gems system and if that is actually the definitive library index for Ruby.  This lack of libraries is quite a big deal to me, as I am a big fan of not reinventing the wheel unless it is absolutely necessary, so I like having lots of high quality libraries I can use.  That also speeds up prototyping efforts as it is easier to hook up existing libraries than write the same functionality from scratch again yourself.

In summary when I consider learning Python or Ruby for scripting, rapid prototyping and with added dimension of writing a website with an MVC framework.  I think I would now reverse my decision and learn Python rather than Ruby.  If I was still just thinking about scripting and prototyping with these languages I would consider the two languages evenally matched.  With Python having an advantage with the apparent range and quality of its libraries and Ruby having an advantage with its support of Public/Private class members which I am more comfortable with.

It was not until I started helping out with RockClimbing.com for a brief period which exposed me to a large scale php project supporting many thousands of users.  With its advanced language usage, separation of code, content and layout with smarty templates, advanced caching and high performance database queries (one of the developers ended up working for MySQL iirc) it was beyond anything I had seen before.  All this opened my eyes to how to architect a site in php correctly and that it could be a truly elegant language to work with and I am not alone in this feeling.  Then for a period of several years my personal site fell into disuse as I was distracted by work and life from doing any active web development.

This year I decided to start this blog on a new domain name and start writing about software engineering and programming.  My choice of blog engine?  WordPress: which is a php based blogging engine which runs with MySQL as its database.  I found myself tweaking my WordPress installation almost immediately and I found it easy enough to do as php was already familiar to me.  In fact I’ve been tweaking so much that I’ve now set-up a Perforce server at home so I can track, audit and keep a log of my changes.  As I’ve explored the WordPress code base over the months, I’ve noticed that it is not the prettiest of code in place and again I’m not alone in noticing this.

Please don’t misunderstand me, I like WordPress a lot, it has made setting up and running this blog trivial, especially when compared with writing my own blog engine from scratch. I’m simply commenting on my perception of the quality of the underlying source code, something I think all programmers do especially with things they’ve written (although I did not write WordPress, I just modified it).  It would be nice to see a code tidy up and the introduction of templates and caching to the core engine, but that is a big job to undertake and I don’t think I have the required amount of spare time to achieve it myself.

All this has got me thinking about the recent(ish) upsurge in the number of web development frameworks that are embracing things like Object Relational Mapping (ORM) and development models like the Model-View-Controller (MVC) pattern.  The two programming languages that seem to be leading this charge are Python with DJango and Ruby with its Rails framework, no doubt there are other frameworks in other languages too (e.g. ASP MVC, php’s symfony framework).  The increase in popularity of these frameworks with built in template engines and abstraction of content from layout and logic via MVC are making me consider setting out on the path of writing my own personal blog engine again.

Mostly writing my own blog engine is a way to learn and embrace these new technologies and concepts and also a chance to see what all the fuss is about.  This would mean leaving the cosy comfort of my WordPress armchair, so most likely this experiment will become something I initially develop in a test sandbox at home until I have something that is worthy of publishing online.  My decision now is what language and framework to use.  Do I stick to php with Smarty and MySQL or do I try something new like Python’s Django or Ruby on Rails?  Right now I’m tempted by either Python or Ruby for reasons I will talk about in a post tomorrow.