Most of my professional experience in software development has centered around Java.  That should be no surprise as I learnt Java in university, and all the trappings that go with it: Javadoc, the Java Standard API, Eclipse and JUnit.  My professional work exposed me to JSP, Servlets, SpringMVC, Struts, JDBC, TestNG, Ant and the Android SDK.  Sure I’ve used other languages such as PHP, Perl, Scheme (mmm… functional programming…), C and Prolog.  The mainstay of my experience is still Java.

All that said, even as I include more and more exotic features of Java as language (i.e. enumeration, annotations, reflection, etc.) and as a platform, I find myself more and more constrained by the language itself.  Sure I feel comfortable with it, and I’ve written code personally that spans tens of thousands of lines.  However I find a lot of the code is boilerplate code.  Heck thanks to JAXB, I can quickly describe a series of classes using a XML schema.  That is right, a XML schema, one of those awfully obscure XML trappings that only enterprise application developers really should ever care about (or those working with complex document-style data).  Also a large Java codebase is nearly unapproachable with anything less than a powerful IDE.  Thank goodness for Eclipse!  (I write this wearing an Eclipse branded fleece jacket.)

Java is a wonderful and powerful language with great tooling.  However it just seems so wrong to have so much complexity.  I fear that this has more to do with the design decisions in the language itself than anything else.

Enter the Competitor: Python

I also learnt Python in university but I ended up using it largely for building system administration scripts rather than a general programming tool.  Instead of fighting with unwieldly BASH or Batch scripts for admin work, I use Python.  And I have created some powerful scripts using Python for tools for hunting down empty directories and rogue files for automated renaming.  After fighting with Java to do my bidding, I felt the need to look for some better language when building my new hobby project.  Also my recent attempts at learning Qt and C++ at the same time, have made me want to first learn the platform and then the language.  This is where Python seemed to hit a sweet spot.

While talking with one of my old university friends, Dan D’Alimonte, the topic of learning Qt came up.  Instead of using C++ for his Qt apps, Dan used PyQt.  After looking at his code, I decided to experiment with PySide and lo and behold I made a Qt app myself!  On the web side of things I heard a lot of good things about the Django web framework.  Hence I started experimenting with and investigating Python, PySide and Django.  In addition to the simple can-I-do-this-with-that experiments, and playing around with the tutorials, I researched the tooling and performance of Python based applications.

I am impressed so far with what I have found out about Python.  Coding in Python is a breeze and enjoyable.  I can comfortably use any text editor to program in Python.  I found that PyDev makes Python development while using Eclipse easy.  Getting new packages for Python is simple, and I do not have to rely on a package maintainer.  The standard libraries in Python are on par with Java’s.  You can always extend Python with a C or Java binding.  Building a desktop app using PySide turned out incredibly easy, compared to the standard C++ way of doing things.  Django is proving to be a very capable, and apparently *gasp* fast web framework especially when run on the optimized PyPy version of Python.  There is even mention of Python being able to build web frontends, at least in the documentation.  And importantly for me, Python has various XML, database layer, testing, and other enterprise and mobile capable libraries that I can potentially use in my day-to-day work.

Now naturally the quirks of a language become more readily visible once you actually start working on a real-life project.  That is my next step.  Then I can figure out if Python could really replace Java as my go-to language.  I will keep you posted once I get further in the project I am working on.  In the meantime, I’ve collected a bunch of links related to my investigation with Python.  Enjoy!

Python Related Links

• Python’s official website: http://www.python.org/
• Documentation for the Python 2.7.x: http://docs.python.org/
• PySide – Python bindings for Qt: http://www.pyside.org/
• PySide documentation: http://qt-project.org/wiki/PySideDocumentation/
• PyDev – the PyDev plug-in for Eclipse: http://www.pydev.org/
• Django – a powerful web framework: https://www.djangoproject.com/
• Django documentation: https://docs.djangoproject.com/en/1.4/
• Proboscis – A TestNG-like testing framework for Python: http://packages.python.org/proboscis/
• PyPy – An optimized implementation of Python: http://pypy.org/
• Comparisons of PyPy to the original CPython: http://speed.pypy.org/
• Jython – Java implementation of Python in case you can’t live with out both!: http://www.jython.org/

As for myself I’m on Twitter because there are a lot of people that are not on my favourite microblogging platform: Identi.ca!  With Twitter being a bit more accessible on my Android smartphone and the smaller crowd on Identi.ca, I sort of stopped using it for a bit.  However that will change.  I prefer Identi.ca because it is libre software and my data is not held hostage in some corporation’s database.  I’ve updated my Identi.ca handle, wired up my microblogging widgets back to Identi.ca (and Twitter).  Now I plan on using it more often, and pushing my blog updates through Identi.ca first and then on to the other three popular social media that I use.  If everything goes as planned y’all should be able to read this post in a few moments after I publish it… right now.

So while I can not comment on my own work… I can point some interesting work happening in the libre software community.

Canonical’s New Take on Scrollbars

Many of today’s computing innovations like tablets deal not with radical new technologies.  But rather making technology more usable for non-developers and non-engineers.  It might not sound like much, but Canonical is working on improving the usability of scrollbars in their Gnome desktop: http://www.markshuttleworth.com/archives/615

Take a look at the video in Mark Shuttleworth’s post.  I definitely think that abstracting the line indicator and the actual control is a great idea.  It also makes it more touch friendly and intuitive.

MeeGo and Qt Lives for KDE and the N900

While not so much an innovation per se, I am happy to hear that the development of Qt and MeeGo will continue.  The KDE crew came out and pointed out that Qt back when KDE started was a great framework and is even better now.  Back when I started using KDE, I was amazed at how well everything integrated together in look and feel terms.  This was all possible with KDE settling on one good UI framework, Qt.  Now that it is more cross-platform and rounded out, it still is a great compelling framework to learn and use.  There are some governance issues that need to get worked out, but it is nothing that won’t be resolved nicely soon.  I indeed intend on learning Qt, as soon as my own schedule clears up.

[Another analysis on the Nokia/Qt/MeeGo/KDE question.  Man isn't life in the libre software world messy at times.]

As for MeeGo, sounds like Nokia will be supporting the N900 as an official development device for MeeGo.  So maybe Mr. Elop changed direction, but at least there is a way forward for MeeGo handset developers.  Hopefully that’ll mean that we can get started hacking on MeeGo.  And once more devices come out, all developer efforts can get carried over.  Maybe, just maybe we’ll finally have a good libre software platform for new disruptive devices, that won’t be threatened by the domination of one massive vendor.  I’m looking at you Google, Microsoft and Apple.

Well before Linux got off the ground or even existed, Richard Stallman (RMS) started the GNU project.  GNU stands for GNU is Not UNIX. Yes, GNU is a recursive acronym, one of the many cute jokes circulating in the hacker community.  The goal of the GNU project was to build a working and totally free (as in freedom) operating system.  RMS settled upon porting UNIX, not because UNIX was the be-all-end-all of operating systems.  Rather older versions of UNIX came with source code, and so that the new OS could be based off studying the way the old System V UNIXes  worked.  The project progressed well with the development of an entire toolkit: source editor (EMACS), compiler (gcc), linker (ld), and all the other necessary tools to build an OS.  Then came the difficult part of writing a kernel.  Unfortunately the original kernel (GNU Hurd) never got off the ground.  In fact to this day, the Hurd kernel is more or less in delayed development.  Fortunately at the time a kid in Finland-Linus Torvalds-started hacking on a kernel based off the Andrew Tannebaum’s MINIX source code.  Torvalds decided that the GPL would be an excellent license for his kernel.  And thus the dream of a fully viable free operating system started.

We have come a long way since those humble beginnings.  GNU/Linux looks like it will be the dominant OS of this century.  Also the ideals of free software are now fully realizable.  We still have a long way to go to running free software conveniently and comfortably, but we are getting there.  We should thank RMS and all the GNU contributers for building such a great free software toolkit.  Also thank Linus and the other kernel hackers for creating such a robust and flexible kernel.  Finally give a big thank you to all the contributers of the free software and open source movements for making this dream of free computing a reality.

justCheckers logo

I’m putting my involvement with the justCheckers project on hold for a while.  Progress ground to a halt when I started to dig into the code.  In its current state most of the application’s core functionality needs reworking.  Meaning to go forward someone would need to reimplement slides and jumps that allows for multiple jumps and so-called “flying kings”.  And the GUI needs refactoring to run in a multithreaded manner and with a main game event loop.  I already devised the algorithms for the core game engine.  But I need to translate that into real code.  I plan on implement those eventually.  But the amount of effort to reward doesn’t add up at the moment for me.  So justCheckers will not be on my high priority list for the next little while.

Just to be clear, I am not abandoning the project.  I still want to work on it.  But there are higher priorities on my list.  If anyone wants to step up to the plate and massage the code, I’ll gladly help.  And when once I get my other higher priority tasks done, I will return to hacking on justCheckers.

Richard Stallman, President and Founder of the FSF

Yesterday I got to finally meet Richard Stallman (RMS) in person.  And yes, he is a way cooler dude than many in the “open source” gang say he is.  The FSF announced a while back in a press release, that RMS would be speaking at UofT on the topic of copyrights in a networked world.

RMS lectured on the history, current politico-business problems with copyrights and some measures to fix them.  I personally found his points interesting, and I’m interested in trying out some of his ideas.  The brief period of exclusive commercialization and modification authorship rights versus long term exclusive publication rights for non-technical documentation is also pretty good.  Also he briefly touched upon the need for a micro-donation payment method.  Overall, a very interesting and engaging talk to a large student audience.

At the end of his presentation, he auctioned off a stuffed GNU and “Happy Hacking” t-shirt.  Eventually the proposed prices became too steep for even myself, so I this morning I went on down over to the GNU/FSF’s online store and bought both for myself.  Getting back to the evening, I also got RMS to autograph my copy of “Free Software, Free Society“.  I highly recommend reading that book.  Also RMS asked me personally to stop using the terms: open source and closed source.  Not only are those terms misleading but they totally ignore the important issue of user and developer freedoms.  So henceforth I’ll try to use the terms “libre software” or “free software” instead of “open source”.  And “proprietary” for “closed source”.  Also I got meet to Dave, one of the organizers of the event and DrProject developer.  And Aaron one of attendees.

A big thanks to RMS, the FSF and the students who organized this event.

#! /usr/bin/env python
"""    Symlink Mirror -----------------------------------------------------------
       Author: Dorian Pula    Version: 0.1    Date: 2008 May 29
       --------------------------------------------------------------------------
       Creates symlinks in the current directory to the top level folders inside
       a specified directory.  Its a great utility for linking a user's home
       directory with a directory holding files shared between users on the same
       system.

       Usage: python symlink_mirror.py [source of links] [target for links]
      --------------------------------------------------------------------------
       This program is free software: you can redistribute it and/or modify
       it under the terms of the GNU General Public License as published by
       the Free Software Foundation, either version 3 of the License, or
       (at your option) any later version.

       This program is distributed in the hope that it will be useful,
       but WITHOUT ANY WARRANTY; without even the implied warranty of
       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
       GNU General Public License for more details.

      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>"""

import re, os, sys, stat

verbose = "True"

def main():
    """ The main function of the program. """

    'Check if there are enough arguments supplied.'
    if checkNumberOfArgs():
         'Make the path directories.'
         sourceDir = os.path.abspath(sys.argv[1])
         targetDir = os.path.abspath(sys.argv[2])

         'Get all the names of the directories.
         sourceEntries = os.listdir(sourceDir)

         for toLink in sourceEntries:
             source = os.path.join(sourceDir, toLink)
             target = os.path.join(targetDir, toLink)
             dirCheck = os.path.isdir(source)

             if((os.path.isdir(source)) and not (os.path.islink(source)) and not (os.path.exists(target))):
                  os.symlink(source, target)
                  if(verbose == "True"):
                        print "Linking " + source + " to " + target + "."

def checkNumberOfArgs():
    """
    Checks if there are enough arguments to work on.  There should be two
    arguments, the directory from which we generate the links from, and
    the directory in which the links appear. """

    argNum = len(sys.argv)
    if argNum < 1:
        print("I need a source directory to mirror.")

    elif argNum < 2:
        print("I need the directory to store the created symlinks.")

    if argNum < 2:
        print("nUsage:")
        print("python symlink_mirror.py [source of links] [target for links]n")
        return False

    else:
        return True

if __name__ == "__main__": main()