In turn, I hope to encourage the use of my current favorite language, Python (see http://www.diveintopython.org/ for a good tutorial). For an interpreted language (it does compile to c byte code at runtime), its capabilities and community support are overwhelmingly substantial. I’m continually surprised as I discover more; its breadth is so great, that Python leaves itself open to satire ( also: here and here). I could drone on,  evangelizing its advantages at some detail (and bore everyone to tears, I’m sure), but that’s not why I’m writing today. No, the point here is to give a quick presentation on a particular package I’ve just started using that amazes me, and it should get more use: wxPython.

WxPython is module for Python that is essentially a wrapper for an open source project called wxWidgets, so most of the credit should go to them. WxWidgets is certainly widely used (link: http://wxwidgets.org/about/users.htm ); it’s a package that allows developers to quickly and easily access the GUI components in Windows, OS X, and various flavors of Linux. This allows development of applications that look native to the OS. WxPython allows one to rapidly develop applications entirely in Python, that look native to the OS. Imagine writing an application in OS X, then moving the code to a Windows or Ubuntu machine and having it work and look perfectly without any modifications! No more dealing with .dlls or compiling on individual machines.. just ‘python <appname>.py’.

In practice, it’s surprisingly easily to generate an entire event-driven application. The basic order of implementation is (1) design layout of your buttons,menus, widgets, etc, (2) implement event handlers, (3) bind event listeners to buttons / actions. I’d post some of my code, but it’s almost all currently in an NDA’ed project, so instead here’s some sample code from http://wiki.wxpython.org/AnotherTutorial that creates a program with a toolbar:

#!/usr/bin/python

# toolbar.py

import wx

class MyToolBar(wx.Frame):

def __init__(self, parent, id, title):

wx.Frame.__init__(self, parent, id, title, wx.DefaultPosition, wx.Size(350, 250))

vbox = wx.BoxSizer(wx.VERTICAL)

toolbar = wx.ToolBar(self, -1, style=wx.TB_HORIZONTAL | wx.NO_BORDER)

toolbar.AddSimpleTool(1, wx.Image(’stock_new.png’, wx.BITMAP_TYPE_PNG).ConvertToBitmap(), ‘New’, ”)

toolbar.AddSimpleTool(2, wx.Image(’stock_open.png’, wx.BITMAP_TYPE_PNG).ConvertToBitmap(), ‘Open’, ”)

toolbar.AddSimpleTool(3, wx.Image(’stock_save.png’, wx.BITMAP_TYPE_PNG).ConvertToBitmap(), ‘Save’, ”)

toolbar.AddSeparator()

toolbar.AddSimpleTool(4, wx.Image(’stock_exit.png’, wx.BITMAP_TYPE_PNG).ConvertToBitmap(), ‘Exit’, ”)

toolbar.Realize()

vbox.Add(toolbar, 0, border=5)

self.SetSizer(vbox)

self.statusbar = self.CreateStatusBar()

self.Centre()

self.Bind(wx.EVT_TOOL, self.OnNew, id=1)

self.Bind(wx.EVT_TOOL, self.OnOpen, id=2)

self.Bind(wx.EVT_TOOL, self.OnSave, id=3)

self.Bind(wx.EVT_TOOL, self.OnExit, id=4)

def OnNew(self, event):

self.statusbar.SetStatusText(‘New Command’)

def OnOpen(self, event):

self.statusbar.SetStatusText(‘Open Command’)

def OnSave(self, event):

self.statusbar.SetStatusText(‘Save Command’)

def OnExit(self, event):

self.Close()

class MyApp(wx.App):

def OnInit(self):

frame = MyToolBar(None, -1, ‘toolbar.py’)

frame.Show(True)

return True

app = MyApp(0)

app.MainLoop()

results in this (on Ubuntu):

Resulting application in Ubuntu

While not much to look at, certainly, briefly think about what’s going on here. In ~45 lines of code, we have a fully functional application. It doesn’t do much,  yet, but imagine what we could do if you started hooking up some of your existing Python code, or hooking in some other Python modules. There’s a lot of power in this; the mind can hardly grasp the possibilities of, say, Windows apps powered by Python (take that, Visual Studio). I feel strongly that it has the potential to handle some serious projects, if given the opportunity.

This would be intensive, but I’m still learning wxPython myself. So far, it’s been great fun, and I highly recommend others to check it out. I’d love to see some examples out there of anyone who’s developed apps in the framework (a quick search doesn’t reveal much), and perhaps I’ll post some of my own as I start using it more.

Until then, try taking a look at wxPython.org (link) and the wxPython wiki (link). Give it a shot; I’m sure you’ll love it.

At Cantina, we make heavy use of all that Google Apps has to offer to provide a cost effective, yet extremely functional solution to email (both web-based and IMAP) and shared calendars. This, for the most part, suits our needs adequately and with minimal cost and maintenance. Now, throw into this scenario the fact that we are consultants, and as such end up making heavy use of our clients’ respective email and shared calendar solutions, most if not all of which are handled via Microsoft Exchange Server. There are a whole host of reasons why this is a good thing for our clients, however this presents a problem for someone like myself, who likes to keep everything in one place, depending on where I am:

1. If I’m at my desk, I want it on my Mac laptop and want all of my email managed via Apple’s Mail application, and all of my calendar managed through iCal
2. If I’m out and about, I want it all on my iPhone (you can see my brand allegiance here – not a fanboy just like low maintenance and high integration)
3. If I’m really in a pickle and don’t have my laptop or my iPhone (this is rare), but still have internet, it would be ideal to have a unified web interface to get to all of this stuff, perhaps via Google Apps. Again this is a rare case.

Now, there are a myriad of synchronization technologies and solutions out there that attempt to bridge the gaps between these various components, such as:

• IMAP: Apple Mail – Google Apps Mail & Gmail (works great apart from the lack of Label/Folder IMAP subscription)
• Apple Mail’s Exchange Support: Apple Mail – Exchange (still requires IMAP to be enabled, which isn’t always the case)
• Spanning Sync: Google Calendar/Contacts – iCal/Address Book
• Entourage with Sync Services: Exchange Calendar/Contacts – iCal/Address Book (issues with multiple exchange accounts)
• NuevaSync: Google Calendar – iPhone (over the air, doesn’t require cable, yet takes up your only Exchange account on the iPhone)
• Active Sync on the iPhone: Exchange – iPhone (over the air, but only supports one Exchange account at a time)
• And so on…

All of these little “bridges” spanning the gaps between various applications each have their own small set of problems and limitations which makes this whole sync ecosystem break down. What’s worse, is that sometimes, attempting to make this work can have unintended or potentially disastrous consequences (Imagine all your calendar events from one client syncing onto another client’s Exchange server).

So there’s the problem, but what is the solution? For many people, a single Exchange or Mobile Me account will do the trick, but for me (a consultant using multiple services), it does not. Sure, there are some glimmers of hope. Apple is bolstering their Exchange support in their applications following the introduction of Active Sync to the iPhone. Sure, there might be a day soon when the iPhone supports multiple Exchange accounts and can subscribe to CalDAV on Google.

These are all patches to a solution that lacks a holistic view of the problem. Where have we seen this before? How about a unified login? OpenID attempts to solve the real and very present problem of managing separate authentication credentials across the vast ocean of sites requiring registration on the web. Though it’s not quite a homerun yet, there’s progress being made. Any standard will run into this issue, even HTML.

The questions here are these: Can we extend this concept of online identity beyond logging into sites? Can we aggregate our various online presence (including email & calendars) to our one true e-self? I think the answer is yes, but in time, and I think Apple’s lowly Address Book application, the humble servant of contact management on the Mac may serve as an example. You see, in Address Book, there is a particular contact card that is designated as “Me”, the current user. In this contact card, I can add any number of phone numbers, fax numbers, etc., but more importantly I can add multiple email addresses and IM screen names, which all are identified as “Me”. This means that no matter what email address in Apple Mail I use to send or receive email, if it’s in my “Me” card, the system knows it’s “Me”. I think that this very basic approach can be extended to aggregate online identity at a much higher and more meaningful level, across the various services I might use as a result of my online existence. Now we just have to agree on what that will look like, and if history has taught us anything, it won’t happen fast.

Thoughts?