Iterative Excellence

Using an iPhone with WEP wireless

noreply@blogger.com (Tim Mackinnon) — Tue, 28 Jul 2009 12:00:00 +0000

Something that I didn't find obvious when trying to connect my iPhone to an old router using WEP security (which isn't really that secure, but sometimes recycling old pieces of kit is the right thing to do) - is how you specify a password.

I kept trying to connect, using the password I had configured the router to use, however the iPhone simply wouldn't connect. Eventually after a bit of searching I discovered the trick:

Use the 13 hex digits of WEP key1 (generated from your passphrase) but PREFIX it with a $ for the iPhone. e.g. $3a01e1071e5054c9c30d01e3e1

Apparently this is some Apple convention, which is totaly obscure...

Firefox 3.5 - DuplicateTab and OSX compression

noreply@blogger.com (Tim Mackinnon) — Mon, 27 Jul 2009 09:47:00 +0000

I've long been a fan of the Firefox web browser. I know that on a Mac many people use Safari - and I tried exclusively using Safari when I first got my Mac, however I missed the huge catalogue of browser extensions that are available in Firefox, and I also couldn't get used to how bookmarks work in Safari.

I'm not saying that bookmarks are perfect in Firefox - but in Safari I never really got comfortable with the layout of bookmarks (it doesn't seem to map onto a simple folder metaphor - e.g. I never worked out the difference between the Collections and Bookmarks "top level folders" in the manage bookmarks window). Somehow it all seemed a bit cumbersome - when all I really wanted was to categorize a few pages. Firefox is much better in this respect, particularly with its Awesome Bar and keyword tagging (where I mainly don't bother with folders and just keyword tag - particularly now that the XMarks extension suggests tags for me). I will say that my only complaint is that if I want to simply view all my links with a particular tag - its not so easy. There is "recent tags" but if it's not so recent then I'm a bit out of luck. You can open the "Organise Bookmarks" window and then start filtering - but having another window seems a bit cumbersome - I guess I miss being able to type something like - tag:iphone in the awesome bar...

Of course its this kind of thing that Add-On's are designed for - and there is a tag filtering add-on called TagSifter (which has a nice Tag cloud), however its not yet available for Firefox 3.5. However you can get around this by editing the manifest of an add-on and manually changing the MaxVersion requirement. But there are a few tricks to be aware of when using a Mac - as follows:

Download the add-on to disk (you may ironically have to launch Safari to do this as the plugin may indicate it doesn't support Firefox 3.5 and so won't let you install it - or right-click and use save as...)

Append .zip to the .xpi file, which will let you use the Finder extract the add-on into a folder

In the extracted folder, locate the "install.rdf" file, and open it with a text editor. Find the line: em:MaxVersion= and change the number to 3.5.*

The following is the important part on a Mac - you need to re-compress the extracted folder, however if you right click on the actual folder you end up with everything being zipped one level too deep. Thus you need to select all of the files inside the folder and then right click and select Compress. You will get a .zip file inside the folder which you can then rename to something like -3.5.xpi and then you can move your new file into the parent directory.

Finally, you should now be able to drag your new .xpi into Firefox and it will prompt you to install the new add-on

Hopefully this helps anyone else who upgrades to Firefox 3.5 and still has 3.0 extensions that they want to use in the newer version. I found this worked for both TagSifter as well as another favourite add-on, DuplicateTab.

reference: forums.mozillazine.org

ReDo iPhone productivity app

noreply@blogger.com (Tim Mackinnon) — Tue, 07 Apr 2009 12:12:00 +0000

I've always been interested in PDA's right from my first Casio programmable calculator (which had notes and calendar functionality). Following on from that early experience were a series of Palm devices (one even having a bulky clip-on phone module), a Sony Ericsson P910i, an HTC Windows Mobile device (very unreliable), back to the P910i, and then finally an iPhone 3G.

Of them all, I really like the iPhone, although I do miss many of the features that I had on those previous devices (some of which will appear in the 3.0 OS). Of course the nice thing about PDA's is the ability to buy or write your own applications to fill in the gaps.

While I briefly toyed with writing Palm applications, I never invested the time to write something "shrink wrapped" for it. The tools seemed quite cumbersome, and it felt like a very primitive exercise to write anything of note. However I have always maintained a list of ideas for things that I want on a phone/pda to help me in day to day activities.

Late in 2008 - when I decided to upgrade our office to using iPhones, part of my selection decision was based around revisiting writing applications for mobile devices. I felt that Objective-C was a good match for my previous Smalltalk experience and XCode is a respected development environment.

Today, I am pleased to say that I have successfully released my first iPhone application, ReDo. It's a practical "does what it says on the tin" application, that ticks off one of those items in that "helping me getting things done" checklist I've been mentally carrying around.

You can get a copy of ReDo on the App Store or on the Iterex iPhone" page. Needless to say - I've been using it a while to maintain lists of items I need to remember to redo when I give a presentation, or pack for a vacation. Hopefully others will find it as useful as I do.

Update: I have received several unsolicited emails with very encouraging feedback, so it seems that others are ReDoing items as well.

Rescuing Posts From the Past

noreply@blogger.com (Tim Mackinnon) — Wed, 03 Dec 2008 09:05:00 +0000

Its very easy to lose parts of your past, and while Google, Yahoo and Msn do good jobs of indexing and caching our records you do often find broken links to historical information.

In an effort to simplify my infrastructure (and save save some money) I have decided to change my ISP. I blame it on the iPhone - well actually the iPhone has given me a reason to properly sync some of those podcasts I've been meaning to listen to. I dutifully located some of my favorite blogs which have podcasts: Industry Misinterpretations and Hanselminutes. I also found some new contenders, Floss Weekly and the Motley Fool Moneytalk. I like having a diverse set of topics to listen to on the way to work - possibly this is akin to mental calisthenics?

Anyway it was the latter podcast (Motley Fool) which had an old conversation on ISP's, which caused me to re-evaluate my situation. Looking at some of the comparison sites I found that I was paying double for a lesser service - with the final kicker being a series of technical problems with my ISP in the last few days. That was it, I decided to switch - and I have been suprised how much easier it is to do this now. The last time I did it was more than 10 years ago, and I still remember how convoluted it was to get everything changed over. This time most things seem quite automatic - you request a MAC code (similar to the PAC code for a phone) and enter it into your new providers website, and then you cross your fingers (I guess).

Of course once the die is cast, there are other things to consider. Something I did a long time ago, was use a mail redirector (I use Pobox.com) - and while its a paid service - they have been very reliable and helpful over the years. I guess these days most people use Google for email, but before Google you generally used the email address from your ISP, and so it was painful to mail all of your contacts and get them to change your email details if you changed. This is where a redirector pays off - you keep the same email address and you just login to your service and move the destination to wherever you want email to go. This is perfect when changing ISP's (I pointed my mail redirector to deliver to the address of my ISP) but it also occurs to me that its great for technical problems as well. Even Google suffered some technical problems a few weeks ago, and for this its easy to divert your email somewhere else (or indeed - just multicast your email to several locations so that you have a backup to go to in the case of problems).

This leads me back to rescuing data from the past. In doing my final tidy up, I discovered some of my first blog posts, and also some Smalltalk projects that I had forgotten were hosted on my ISP's server. I still use those libraries, and while they are version controlled on my network they may still be useful to others and so it makes sense to move them from the old http://www.macta.f2s.com to my main website, Iterex Planning Cards.

Hopefully this post leaves some breadcrumbs for anyone doing some archaeology...

Printing From a Mac to a Shared XP Printer

noreply@blogger.com (Tim Mackinnon) — Thu, 16 Oct 2008 00:37:00 +0000

Having tested the water, and moved from Windows XP to Mac Leopard OSX - it has been driving me crazy that I can't easily print at home.

It seemed like it was supposed to work - the Add Printers dialog has a button for Windows printers - but it just remained blank. My old Vaio laptop could see my Desktop's printer, but not the Mac.

I searched on the internet, and learned about Cups but that didn't work.

At one point I considered a hardware solution from Edimax, and then tonight I happened to type in the magic search words "Windows XP LPR" and boom - there it was, the magic recipe for printing from OSX Leopard. It lists some very detailed steps, and there are a lot of them, but by god it works.

Many thanks for R Harder for publishing this...

First Impressions of a Mac Air and OSX

noreply@blogger.com (Tim Mackinnon) — Thu, 16 Oct 2008 00:09:00 +0000

After hearing countless colleagues extol the benefits of Macs and OSX, I decided that my next laptop would be a Mac.

My Sony Vaio has been a great workhorse - running Windows XP and carefully managed so that it was kept free from too many software addons, it has been a relatively stable environment. I tend to reboot it once a month and its suspended and resumed several times a day without incident. However it is slightly heavy (the laptop is 1.6kg however the power supply is another 500g) particularly if you carry it around all day between meetings (I certainly didn't want anything weighing more).

For me the ultimate laptop allows light weight development on the move, as well as allowing for email and presentations while on client sites. I really was interested in a MacBook Pro - however the weight was just too much for me to lug around every day, so I decided that the Mac Air might just fit the bill.

There is lots of information already written about the Mac Air, needless to say its not cheap but you do get a quality machine.

For me its definitely been a relief walking around with something so light on my back - and its not just the machine, but also the miniature power supply that goes with it.

On the usability front, the screen is small but bright - the autosensing brightness adjustment is cool but I disabled it as I found that moving my head while typing in low light conditions caused it to change brightness in a distracting way. The backlit keyboard is surprisingly useful (even though I am mostly a touch typist).

The trackpad works very well - I thought the Vaio was good, but this is excellent particularly the gesture support for scrolling and navigating forwards and backwards (annoyingly many applications, even those from apple, don't support it - thank god for multi clutch).

On the not so well, the European keyboard is not well layed out - the miniture Enter key is silly (not sure what happened to Apple design on that one), I also find the use of the four keys on the bottom left of the keyboard (Fn, Ctrl, Alt, Cmd) to be very confusing. I am never sure which key to hit to move forward by word (Alt-Left), to Delete a character (Fn-Backspace) - it seems that surely 3 keys could do the job somehow.

On the OSX front - its good, but maybe I was hoping to be amazed and I'm not. I like that its built on top of Unix - although I'm not a mega command line freak (still its nice to use it from time to time, although I wasn't expecting to have to use "shutdown -r now" when I found that one day Finder Restart refused to restart my machine). I also find the menubar and the concept of having to quit applications rather than close a window to be a little confusing. It definitely drives me crazy that you can't invoke menu items using Alt-Mnemonic Letter - in fact while many apps have good keyboard support its often an afterthought.

Spotlight is working very well for me, its my graphical command line, and its very efficient. TimeMachine is also an excellent idea - and the way it works is nicely thought out (I was impressed to notice that Araxis Merge makes use of it to allow diffs against automatic file history which is very neat).

In many apps, I often find that funny dialog boxes obscure application screens and they can't be moved around, or if you switch to another application athen then back again, any dialog windows just disappear (e.g. Add Printer). The file dialog is also quite confusing, it took me ages to spot where you create a new directory (the new folder button tucked away at the bottom), or how you know the context of a file you are saving (the drop down folder list displays your directory history in a vertical list box). I also miss miss the windows task bar with its running buttons - I think that was a more intuitive way to see what was running rather than the little dots below applications in the Dock (or if you use expose, its flashy but I don't find its little animated mini windows particularly good for switching quickly between multiple Pages documents, and Cmd-` is a little awkward).

Overall, a change is always good for the system - its not a revolutionary change that the fans predict, but its definitely a pleasant one.

Practicing Receiving...

noreply@blogger.com (Tim Mackinnon) — Mon, 31 Mar 2008 22:40:00 +0000

Scott Hanselman has a poignant post about thanking those who helped you get to where you are now. It's so easy to forget to say thank you - so it was good to read Scott's story and think about who I might thank.

While I'm sure we all have have many appreciations of our own to give, I wanted to call out something just as important - How to properly receive appreciation from someone and just say "Thank you", or "Your Welcome".

Nancy Kline in “Time to Think” writes:

¨In exploring why so few people appreciate each other directly, I discovered the problem lies in people doing such a lousy job of receiving. Being appreciated increases your intelligence. It helps you to think better. So don’t utter a hissing “humph”… Those dismissive responses actually insult the person who paid you the compliment. And insults are a thinking inhibitor. Just say Thank You."

This is one of the messages I talked about at QCon London, where I also explored the relationship between Agile Development and Appreciative Inquiry. Too often we forget to practice saying thank you, as well as feeling comfortable saying your welcome.

Nancy also writes that "Lasting relationships exhibit a 5:1 ratio of appreciation to criticism".

I know I often struggle to balance the ratio in this direction. So just like Scott - maybe its time to practice redressing that balance - but also don't forget to practice receiving kind words as well...

Smalltalk Announcement Experiences

noreply@blogger.com (Tim Mackinnon) — Tue, 25 Mar 2008 16:51:00 +0000

In a previous post, I described how I was interested in trying out the Announcements Framework in Dolphin Smalltalk and seeing how it changed my code.

Having ported the code to Dolphin, I set about looking at places where I had used Symbolic events and seeing how I might make use of some of the features of Announcements.

I noticed a common pattern in my GUI components (Dolphin has a very interesting GUI compositional model that bears further discussion in a separate post because it really is quite elegant) where I was looking for specific events on my model in order to update a tree widget.

(Array with: aStoryProject backlog with: aStoryProject plan)
        do:
            [:each | 
            each
                when: #itemUpdated:
                    send: #onItemUpdated:
                    to: self;
                when: #itemAdded:
                    send: #onBacklogChanged:
                    to: self;
                when: #itemRemoved:
                    send: #onBacklogChanged:
                    to: self]

I decided to make two changes - the first being adding "," concatenation to my model (copying the idea that impressed me with AnnouncementSet), and then implementing #when:do: in the resulting ModelSet object. This made my code a little more compact:

(aStoryProject backlog , aStoryProject plan)
        when: StoryCardUpdatedAnnouncement 
        do: [:ann | ann treeModelUpdate: self model: treeModel];

        when: StoryCardAddedAnnouncement, StoryCardRemovedAnnouncement 
        do: [:ann | ann recalculateFilterFor: self ].

I also created a hierarchy of StoryCard announcements, which I could then add methods to (in this case #treeModelUpdate:model: and #recalculateFilterFor:) and then call in my announcement Blocks. This change reduced a lot of clutter in my code, as these methods replaced the #onXXXX: methods that were sitting in several GUI components (some confusingly inherited, and some blatantly copy and pasted). The use of the "," operator for the Added and Removed announcements also feels a little more expressive as well.

As I worked through more examples, I also noticed that if my models start announcing changes, then I need a way to conveniently tie those announcements to GUI objects in a Dolphin manner:

model: anIteration
    | velocityProposer |
    super model: anIteration.

    teamSizePresenter model: (anIteration aspectValue: #teamSize).

    velocityProposer := VelocityProposer for: anIteration.

    suggestedVelocityPresenter model: 
      (velocityProposer aspectValue: #suggestedVelocityRangeString).
    suggestedVelocityPresenter model aspectAnnounces: VelocityChanged.

The above code shows how a normal number presenter can be bound to a #teamSize aspect of anIteration model. However it's also useful to bind to other types of aspects like #suggestedVelocityRangeString which can change dynamically by way of an Announcement (in this case VelocityChanged). This is analogous to the Dolphin #aspectTriggers: method, but instead works for announcements.

I'm still feeling my way through converting to using Announcements, however so far I have been quite pleased with the results. They haven't been ground breaking changes, but they certainly feel tidier

Announcements Framework for Dolphin Smalltalk

noreply@blogger.com (Tim Mackinnon) — Tue, 25 Mar 2008 14:29:00 +0000

I while ago I read an interesting article about Cincom Announcements, which pointed out that while most things in Smalltalk are an object in their own right - triggered events have traditionally only been a Symbol (possibly due to the 640k limit of the early Digitalk Smalltalk).

For me, Smalltalk has always been a language and environment that has so many good examples of how things should be done (MVC, Refactoring, Images, IDE's etc), so understanding how this was fixed was something that greatly interested me.

I frequently program in Dolphin Smalltalk in my spare time, so I was curious how the use of Announcements might change my code. I had already noticed that as my Iterex tracking application became bigger it became more awkward to keep track of what events I was generating, and I was sometimes looking for a good place to put common functionality that appeared in event handlers (I have written about some of my experiences in a later post).

With this in mind, I decided to port the Cincom VisualWorks Announcements package to Dolphin to try it out. Unfortunately my initial attempt was not completely successful - the VisualWorks implementation is surprisingly large (although a large part of this is an extensive suite of unit tests). While I was able to quickly file-in the code and get most things to compile, there was a subset of tests that I couldn't get to pass. These dealt with a language feature of Cincom that is not available in other Smalltalk's - namely ephemerons. While I thought I understood the purpose of these, I was never able to code something that would emulate them to the extent that the tests would pass.

After a few attempts, it occurred to me that I had seen an implementation in Squeak Smalltalk and so I was curious about how this had been done. It turns out that there are actually 3 or more implementations, however I hadn't realised this at the time:

A minimal implementation as part of the OmniBrowser framework and described in the thread: Announcements in Omnibrowser
An extended version of the initial OmniBrowser implementation slightly generalized and separately packaged.
A complete port of the original announcement framework as found in Cincom VisualWorks.

I started out with #2 above, and was quickly taken by how compact the implementation is, although I was also slightly disappointed with how small its suite of tests was (there are tests, but they are very minimal). To understand the limitations of the implementation, I decided to augment the basic tests with those provided with the Cincom implementation.

As I copied each test, I ran it, and if it failed I considered whether it was an important requirement for a basic implementation, or whether it was a more esoteric requirement that I could cover later (in that case I moved the test to a separate package). I ended up with an interesting hybrid of the two implementations.

The Squeak implementation #2 uses a global singleton announcer object whereas the VisualWorks implementation uses an event table on each object - I found that the latter is also much more natural in Dolphin, and in fact as there is already an event table for objects (either directly in the case of Model objects and their subclasses, or indirectly via an external dictionary for other objects) I was able to simply add Announcement in the same place.

I was also quite taken by both Squeak and Cincom's use of AnnouncementSet - and simply implementing concatenation on Announcement to return the composite Set:

, anAnnouncementClass
    ^ AnnouncementSet with: self with: anAnnouncementClass

Furthermore, I was inspired by how the Squeak implementation takes this a step further and also delegates to Announcement or AnnouncementSet to see if it #handles: a particular announcement (this is a a neat simplification of code). This fitted in nicely with the Dolphin implementation as I simply added #handles: to symbol so that it can treat both Annoucements and Symbols similarly in the original code:

triggerAnnouncement: anAnnouncement for: anObject
    ...
    self keysAndValuesDo: [:announcementKey :actions |
                (announcementKey handles: announcementToTrigger) 
          ifTrue: [toAnnounce addAll: actions]].

    announcementToTrigger class broadcast: announcementToTrigger to: toAnnounce

It's also worth mentioning that the last line of the above method paves the way for Meta-Announcments. By delegating to the Announcement class to broadcast its event you have control on how events are sent, and in the Dolphin implementation I have added the following:

broadcast: anAnnouncementInstance to: anEventSet
    super broadcast: anAnnouncementInstance to: anEventSet.
    
    self broadcastMeta: anAnnouncementInstance

Where #broadcastMeta: allows the client to subscribe to MetaAnnouncement's and hence subscribe to all announcements for debugging purposes or simply as a more convenient way to know that events have happened:

broadcastMeta: anAnnouncementInstance
    self announce: (MetaAnnouncement for: anAnnouncementInstance).
    self == ObservableAnnouncement ifFalse:
          [ self superclass broadcastMeta: anAnnouncementInstance].

I haven't played around with these MetaAnnouncments much (but did write some tests for them) - but certainly the debugging aspect strikes me as being particularly useful. This simple trick might be something interesting to roll into the Squeak and Cincom implementations.

Having successfully ported Announcements to Dolphin, I have found that they have simplified some of my code (a topic for a future post). I was also pleased to find that they work well with the Dolphin packaging system and I had no troubles creating my final .exe using the standard tools.

The final Dolphin packages can be downloaded from the Iterex Dolphin Announcements page.

Offline Blog Writing With WLW

noreply@blogger.com (Tim Mackinnon) — Sun, 20 Jan 2008 20:00:00 +0000

When I first looked into blog writing, most offline blog writers were fairly clunky - however in the background I have been tracking Windows Live Writer as it always looked easy to use.

To meet my new years resolution of blogging I decided I would give it a spin. Installation was pretty simple, and while it took me a few moments to figure out how to configure it for Blogger - I easily found some clues online, namely enter the url of your weblog (in my case I am hosting it on my website - http://www.planningcards.com/blog/index.html) and make sure you use your full blogger gmail account.

I have to say, my first impressions are very good. As I often travel, being able to author ideas while offline is very important to me.

New Years Resolutions

noreply@blogger.com (Tim Mackinnon) — Sun, 20 Jan 2008 17:52:00 +0000

Having had several attempts at blogging in the past, but having typically written papers or given presentations I thought it was time to try and see if I can find a rhythm to documenting my thoughts and ideas in 2008.