Develop With Passion®

Screencast - Creating Linked Clones With VMWare Fusion

2012-04-17T09:27:00-06:00

This is a short 11 minute video that walks you through the process of creating linked clones using VMWare Fusion.

VMWare Fusion fully supports linked clones;unlike VMWare Workstation it does not yet have a UI to create and manage them.

This video covers the main points:

How I organize and separate my vms from the vmdks.
Creating linked clones

Shamless Plug - Aside from the first click, no other mouse usage occured during the course of this video, courtesy of keymando.

Develop With Passion®

Fixing header file missing warnings on OSX with native gem compilation

2012-04-13T18:29:00-06:00

Wiped away my install of XCode this evening to install the new version of Xcode (which I installed straight to /Applications!).

Prior to doing this I also completely deleted the /Developer folder.

Upon successfully reinstalling RVM and homebrew using the devtools, I cd’d into a rvm managed folder and did the standard bundle install, upon which time I eventually received this error:

Error - error.sh

: fatal error: 'stdio.h' file not found

I had installed the Command Line Tools for Xcode, but I had not yet switched where it should resolve those tools. Running the following command fixed the issue:

Fix the missing header issue - fix.sh

sudo xcode-select -switch /Applications/Xcode.app/Contents/Developer

Develop With Passion®

Installing RVM with Cygwin On Windows

2012-03-30T18:19:00-06:00

A couple of people have asked me how to get rvm working successfully on windows with cygwin.

I’ll write another post later about how I use devtools to successfully run msys and cygwin side by side from the same set of dotfiles (customized per environment)!

I started with a brand new vm image with the software installed according to the post here.

If you don’t wish to read that previous post just know I installed cygwin to C:\utils\cygwin (for the purpose of this post it you are following along, I would suggest installing to that path also). I also included the following packages (some of these are not necessary for ruby compilation, but they have become my base for a cygwin install):

Archive
- unzip - Unzipping zip files
Net
- openssl - bin and sources
- openssh - Only if you are not going to compile openssh yourself
- curl - download internet resources
Devl
- colorgcc
- gcc
- gcc-core - compiler
- git
- git-completion
- git-gui
- git-svn
- gitk
- libtool - Shared library generation tool. You’ll need it when trying to compile rubies
- libncurses-devel - Used when compiling several other tools I use
- make
- mercurial
- openssl-devel - Required for compiling openssh (not necessarily required for rvm, but I always install it to compile openssh myself)
- readline
Libs
- zlib
- zlib-devel
Utils
- ncurses - Enabling better handling of terminal
- patch - Apply a diff file to an original. Again, you’ll need it when rvm is trying to patch the ruby installs

Once the cygwin install completes we can continue.

Setting Up

Open up a new cygwin session (C:\utils\cygwin\cygwin.bat).
Issue the following commands in the cygwin session:

Get The devtools - devtools.sh

mkdir repositories
cd repositories
mkdir developwithpassion
cd developwithpassion
git clone git://github.com/developwithpassion/devtools
cd devtools

The results should look as follows:

You should now be sitting in the devtools folder so you can now run the kick_off_script:

Prep - kick_off.sh

./osx_or_cygwin_kick_off

Repeat the above step(the first time you run it, it creates a settings file for your user that can be edited further if you are going to make further use of devtools later on)

For the curious, the script is here

The script does the following:
- kicks off an rvm installation script
- updates to the latest rvm
- installs a couple of rubies and sets 1.9.3 as the default ruby

The last step takes a little time to complete, but the end result is definitely worth it!!:

Develop With Passion®

Webinar - devtools - An walkthrough of my devtools setup

2012-03-28T09:19:00-06:00

Today I will be hosting a 1 hour webinar showing you how to get started with my devtools utilities.

Here is the information for the webinar:

Reserve your Webinar seat now at:

This webinar will be an opportunity for people to get an understanding of how I structure my devtools folder and how it is leveraged to facilitate working effectively between osx and windows.

Title: Develop With Passion® - devtools Date: Wednesday, March 28, 2012 Time: 12:00 PM - 1:00 PM MDT

After registering you will receive a confirmation email containing information about joining the Webinar.

System Requirements * PC-based attendees * Required: Windows® 7, Vista, XP or 2003 Server * Macintosh®-based attendees * Required: Mac OS® X 10.5 or newer

Develop With Passion®

April Brussels Course: Rescheduled

2012-03-28T04:52:00-06:00

I am sorry to announce that next month’s .Net Software Craftmanship BootCamp in Brussels, has been rescheduled until the week of September 17th.

Being our first time in Brussels, we are hoping that pushing back the date will provide more people with an opportunity to convince their bosses that the course is a good investment!

I apologize for any inconvienience this may cause.

God Bless You.

Develop With Passion®

April UK Course Rescheduled Until The Week of September 10th

2012-03-28T04:46:00-06:00

I am sorry to announce that next month’s .Net Software Craftmanship BootCamp in the UK, has been rescheduled until the week of September 10th.

Since we only come to the UK once a year, we are hoping that pushing back the date will provide more people with an opportunity to convince their bosses that the course is a good investment!

I apologize for any inconvienience this may cause.

God Bless You.

Develop With Passion®

New Feature: fakes-rspec - multiple args sets captured on ignored/unexpected methods

2012-03-27T23:02:00-06:00

Just added a new feature to fakes-rspec to handle a scenario I ran into. The following test will hopefully explain it:

Interrogating Multiple Argument Sets on the same ignored method - ignored.rb

context "when expanding all of the items" do
  let(:folder){"item"}
  let(:target){"blah"}
  let(:sources){[]}
  let(:args){:sources => sources,:shell => fake} #this syntax is incorrect, but the formatting was getting garbled
  subject{Copy.new(target,args)}

  before (:each) do
    %w[1 2 3].each{|item| sources << item}
  end

  before (:each) do
    subject.expand_all_items
  end

  it "should copy each of the sources to the target" do
    sources.each do|source|
      item = "cp -rf #{source} #{target}"
      shell.should have_received(:run,item)
    end
  end
end

The following line:

Verifying a Call - verify.rb

shell.should have_received(:run,item)

I am testing to see whether the run method (which was never set up to get explicitly called), was actually called 3 different times, and am also verifying that each time it was called it was called with a specific set of arguments.

In the test above I am verifying that for each “source”, a call was made to do a recursive, forced copy, to the “target” location.

Not needing to specify the call while also being able to verify each of the argument sets on each of the 3 invocations of the same method is handy, and introduced solely so I could support this feature that I was working on.

Develop With Passion®

Introducing: fakes-rspec

2012-03-26T17:44:00-06:00

This is a library to aid in the usage of fakes when using RSpec. It adds a bunch of convienience methods and matchers to aid in the usage of the heavily AAA style isolation library.

Installation

Installing - install.sh

gem install fakes-rspec

Or (preferably using bundler), in your gemfile:

Bundler - gemfile.rb

source "http://rubygems.org"
gem 'fakes-rspec'

When you install the gem it will install the rspec gem also, so you will immediately ready to go.

Usage

Creating a fake

Using a let block

Let Initialization - let.rb

describe "Some Feature" do
  let(:my_fake){fake}
end

Inline

Inline Initialization - inline.rb

describe "Some Feature" do
  it "should be able to create a fake" do
    item = fake
  end
end

Configuring a fake with return values for calls

Irrespective of arguments:

Faking Return Values Regardless Of Arguments - code.rb

it "should be able to setup a fakes return values" do
  the_fake = fake
  fake.stub(:hello).and_return("World")

  fake.hello.should == "World"
  fake.hello("There").should == "World"
end

Caring about arguments:

Faking Return Values With Specific Sets Of Arguments - specific_arguments.rb

it "should be able to setup a fakes return values" do
  the_fake = fake
  fake.stub(:hello).with("There").and_return("World")
  fake.stub(:hello).with("You").and_return("Again")

  fake.stub(:hello).and_return("Does Not Matter") # when you use the catch_all, make sure that it is the last step used for a particular method (as above)

  fake.hello("There").should == "World"
  fake.hello("You").should == "Again"
  fake.hello.should == "Does Not Matter"
end

Determining whether a call was made

One of the big strengths of this library compared to some of the other ruby isolation libraries is the ability to let you make assertions against the fake after the [subject] has run its code. The following examples demonstrate some typical usage scenarios:

Irrespective of arguments:

Verifying Call Made Ignoring Arguments - call_verify_ignoring_arguments.rb

it "should be able to determine if a call was made on a fake" do
  the_fake = fake
  fake.hello("World")

  fake.should have_received(:hello) #true
end

With a specific set of arguments:

Verifying Calls Made With Specific Arguments - verifying_calls_made_with_specific_arguments.rb

it "should be able to determine if a call was made on a fake" do
  the_fake = fake
  fake.hello("World")

  fake.should have_received(:hello,"World") #true
  fake.should have_received(:hello,"Other") #false
end

Remember, that because it is just a matcher, to negate the matcher you can use the should_not qualifier to do the opposite:

Determine whether a call was not made with a specific set of arguments:

Verifying A Call Was Not Made With A Specific Set Of Arguments - not_made_with_specific_arguments.rb

it "should be able to determine if a call was not made on a fake" do
  the_fake = fake
  fake.hello("World")

  fake.should_not have_received(:hello,"Other") #true
end

Determining that a call was made a certain number of times

Irrespective of arguments:

Verifying Occurences Of A Call Ignoring Arguments - verifying_occurences_ignoring_arguments.rb

it "should be able to determine if a call was made on a fake" do
  the_fake = fake
  fake.hello("World")

  fake.should have_received(:hello).once #true
end

Caring about arguments:

Verifying Occurences Of A Call Including Arguments - verifying_occurences_including_arguments.rb

it "should be able to determine if a call was made on a fake" do
  the_fake = fake
  fake.hello("World")

  fake.should have_received(:hello,"World").once #true
  fake.should have_received(:hello,"Earth").once #false
end

Remember, that because it is just a matcher, to negate the matcher you can use the should_not qualifier to do the opposite:

Determine whether a call was not made a specific number of times with a specific set of arguments:

it "should be able to determine if a call was made on a fake" do
  the_fake = fake
  fake.hello("World")

  fake.should_not have_received(:hello,"World").twice #true
  fake.should_not have_received(:hello).twice #true
end

After calling have_received, you can specify occurences using one of the following methods:

once
twice
at_least_once
at_least_twice
at_most_once
at_most_twice
at_least(times)
at_most(times)
exactly(times)
occurs(match_block) - Where match_block is a proc/lambda that matches the signature lambda{|number| bool}

An example of using the occurs method would be as follows:

Determine whether a call was not made between a certain number of times

Verifying Calls Using Occurs - occurs.rb

it "should be able to determine if a call was made on a fake" do
  the_fake = fake
  fake.hello("World")
  fake.hello("Again")

  fake.should have_received(:hello).occurs(lambda{|number| (1..3) === number}) #true
end

Contributing

Feel free to fork this codebase and submit any pull requests you think would be useful.

Develop With Passion®

Screencast: Freeing Up System Memory on OSX

2012-03-15T09:01:00-06:00

In this quick video I show you how to use the purge command to quickly free up virtual memory on your machine.

Because I run a fair amount of vms on my machine, at any point in the day I can look at my memory usage and realize that I have almost no memory availabe.

For those that don’t want to watch the video (it’s only 2 minutes), I start the video having almost 6.81GB inactive and only 284.7GB available (and this is a 16GB machine.)

The long and short is I run the following command:

Free Up Your Memory - purge_memory.sh

purge

After the command finished running, I had only 138.6MB of inactive memory and 9.56GB of free memory!!

Here is the video:

Develop With Passion®

Repaving a new Windows 7 VM

2012-03-12T09:15:00-06:00

On Thurday my windows vm image died along with my backup of it!!

I thought this was a good opportunity to repave a brand new vm that I can also create linked clones from to quickly scaffold new vm’s moving forward.

This post is mostly to help me remember the install process and the base tools that I install on a fresh windows 7 vm, as this is not something I do very often!! I included screenshots of most of the install steps, just so I can both remind myself what my defaults are, as well as for your benefit if you wish to copy this setup.

Base Tools Install

Vista Switcher
Ruby
MinGW
Autohotkey
Copy the contents of /to_backup/new_windows_install/startup_software/utils to /c/utils. This folder contains:
- sysinternals
- myuninstaller
Beyond Compare
Executor
Unlocker
msysgit
gvim
cygwin Install the following packages:
- Archive
  - unzip - Unzipping zip files
- Net
  - openssl - bin and sources
  - openssh - Only if you are not going to compile openssh yourself
  - curl - download internet resources
- Devl
  - colorgcc
  - gcc
  - gcc-core - compiler
  - git
  - git-completion
  - git-gui
  - git-svn
  - gitk
  - libtool - Shared library generation tool. You’ll need it when trying to compile rubies
  - libncurses-devel - Used when compiling several other tools I use
  - make
  - mercurial
  - openssl-devel - Required for compiling openssh (not necessarily required for rvm, but I always install it to compile openssh myself)
  - readline
- Utils
  - ncurses - Enabling better handling of terminal
  - patch - Apply a diff file to an original. Again, you’ll need it when rvm is trying to patch the ruby installs

Along with the tools outlined above I also manually compiled the following:

Well that’s it for the base tool install!! There are a couple of other steps I do to configure msys and cygwin to play nice together, but that’s another post!! Outside of that, this is what constitutes my bare minimum for a usable windows vm. From this base image, I can create linked clones that allow me to create project specific vm’s that have further tools installed (such as vs, vs.net etc) specific to the contract/project I am working on.

Still To Come

In a follow up post I’ll detail a set of tools, scripts and code that allows me to configure this entire toolset, so that I can have a seamless environment that supports :

Vim with a host of my favourite plugins
An organized eaash environment with well partitioned dotfiles etc
Simple, plugin style automation tasks

Most importantly, the bash/vim/automation setup I have allows me to share all of the important scripts such as:

dotfiles
automation scripts

On all three of the main environments I work in :

OSX
Ubuntu
Windows (cygwin and mingw)

Until next time!!

Develop With Passion®

Keymando vNext - Automate Your OSX World

2012-02-27T09:00:00-07:00

Between working full time jobs and lots of other responsibilities, Kevin and I are putting the final touches on the next release of Keymando!!

For a long time, we have observed that a large majority of Keymando users are using the tool for just basic shortcut remapping. Since we both use this tool all the time, it is now time to show off some of things it can do, and believe me when I say, that using it for jusk key remapping is a big waste of its potential.

Over the course of the next couple of weeks, I am going to be giving presentations to existing, and hopefully some new users, to show them what they can do with this tool, and the infinite customizations that are now possible with a bit of Ruby magic!!

If you take a look at my current Keymando Configuration Scripts you can see how “basic” my regular shortcut mapping is:

keymandorc.rb

toggle "<Cmd-9>"
map "<Cmd-e>", "<Escape>"
map "<Cmd-Shift-d>", "<Cmd-Shift-Tab>"
map "<Cmd-d>", current_app_windows
map "<Cmd-f>", trigger_app
map "<Cmd-Shift-f>", "<Cmd-Tab>"
map "<Cmd-h>", "<Left>"
map "<Cmd-j>", "<Down>"
map "<Cmd-k>", "<Up>"
map "<Cmd-l>", "<Right>"
map "<Cmd-m>", "<Tab>"
map "<Cmd-,>", "<Shift-Tab>"
map "<Cmd-n>", "<Ctrl-n>"
map "<Cmd-r>", RightClick.instance
map "<Cmd-0>", "<Cmd-Shift-D>"
map "<Cmd-o>",RunLastCommand.instance
map "<Cmd- >", launch_app
map "<Cmd-i>", RunHistoryItem.instance
map "<Cmd-p>", hit_a_hint
map "<Cmd-y>", run_registered_command

The 2 biggest new changes to the Keymando internal engine is that almost everything is modelled as commands. This allows for history, replaying and a host of other features. And the 2nd biggest new feature is the addition of an automation layer we are dubbing the Keymando Automation Engine. To see this engine in action, take a look at my script to manipulate iTunes:

Creating Command To Press iTunes Menu Items - itunes.rb

itunes_command_for_button("iTunes Play",/Play\s*space/)
itunes_command_for_button("iTunes Pause",/Pause\s*space/)
itunes_command_for_button("iTunes Stop",/Stop\s*space/)
itunes_command_for_button("iTunes Previous Song",/Previous/)
itunes_command_for_button("iTunes Next Song",/Next/)
itunes_command_for_button("iTunes Increase Volume",/Increase Volume/)
itunes_command_for_button("Decrease iTunes Volume",/Decrease Volume/)

This is code in one of my configuration scripts under my plugins folder. It will setup one command for each iTunes function. Here is the code for the itunes_command_for_button method (written in the same plugin script):

Leveraging The Command DSL - command.rb

def itunes_command_for_button(name,name_reg_ex)
  Command.to_run :description => name do
    add_block do
      itunes_button(name_reg_ex).press
    end
  end
end

Notice the use of the simple dsl for registering a command. This is one of 2 dsl’s for registering commands. At the completion of the dsl block, a new command with the name provided in the description will be place in the set of available commands to run. And finally, the itunes_button method, shows the use of the Keymando Automation Engine to find the actual button:

Using The Keymando Accessiblity API - accessiblity.rb

def itunes_button(name_reg_ex)
  app = Accessibility::Gateway.get_application_by_name "itunes"
  return app.menu_bar.find.first_item_matching(:title => Matches.regex(name_reg_ex))
end

I will be doing more posts on the Automation Engine over the next little while. In the meantime, looking through the scripts in my GitHub repository should give you an idea of what some of the capabilities are.

The net result of registering all of those commands is that when I press Cmd-y (which is my mapping to run a registered command), it will pop up a list of all of the registered commands based on my settings:

Uploaded with Skitch!

Develop With Passion®

developwithpassion_fakes - A Simple Interception Library For Ruby Devs

2012-02-27T08:00:00-07:00

This is a really simple library to aid in AAA style testing. The primary driver for using this is to be able to make assertions on method calls to collaborators in actual assertions and not as part of setup. It is meant to be used to complement the current testing framework that you are using to aid you when you are wanting to write an interaction based tests.

Installing

Just gem install developwithpassion_fakes. Or place and entry in your Gemfile and let bundler do the rest!
Import the library in the test files you are writing (I usually just place this line in my spec_helper file and forget about it):

require 'developwithpassion_fakes'

Where’s the code

Code for the library is on GitHub. It was written test first, and it was kept clean and small on purpose, as it is meant to be used in conjunction with your existing testing solution.

Working with the library

Here is a simple example

class SomeClass
  def initialize(collaborator)
    @collaborator = collaborator
  end
  def run()
    @collaborator.send_message("Hi")
  end
end

describe SomeClass do
 context "when run" do
  let(:collaborator){DevelopWithPassion::Fakes::Fake.new}
  let(:sut){SomeClass.new(collaborator)}

  before(:each) do
    sut.run
  end

  it "should trigger its collaborator with the correct message" do
    collaborator.received(:send_message).called_with("Hi").should_not be_nil
  end
 end
end

Creating a new fake

To create a new fake, simply leverage the fake method that is mixed into the Kernel module.

require 'developwithpassion_fakes'

item = fake

Specifying the behaviour of a fake

When scaffolding fake return values, the library behaves almost identically to the way RSpec stubs work.

Setup a method to return a value for a particular set of arguments

collaborator = fake

collaborator.stub(:name_of_method).with(arg1,arg2,arg3).and_return(return_value)

Setup a method to return a value regardless of the arguments it is called with

collaborator = fake

#long handed way
collaborator.stub(:name_of_method).ignore_arg.and_return(return_value)

#preferred way
collaborator.stub(:name_of_method).and_return(return_value)

Setup different return values for different argument sets

collaborator = fake

#Setup a return value for 1
collaborator.stub(:method).with(1).and_return(first_return_value)

#Setup a return value for 2
collaborator.stub(:method).with(2).and_return(second_return_value)

#Setup a return value when called with everything else 
#if you are going to use this, make sure it is used after 
#setting up return values for specific arguments
collaborator.stub(:method).and_return(value_to_return_with_arguments_other_than_1_and_2)

Verifying calls made to the fake

Verifying when a call was made

The primary purpose of the library is to help you in doing interaction style testing in a AAA style. Assume the following class is one you would like to test:

class ItemToTest
  def initialize(collaborator)
    @collaborator = collaborator
  end

  def run
    @collaborator.send_message("Hello World")
  end
end

ItemToTest is supposed to leverage its collaborator and calls its send_message method with the argument “Hello World”. To verify this using AAA style, interaction testing you can do the following (I am using rspec, but you can use this with any testing library you wish):

describe ItemToTest do
 context "when run" do
  let(:collaborator){fake}
  let(:sut){ItemToTest.new(collaborator)}

  #I typically use a before block to specifically trigger the method that I am testing, so it cleanly
  #separates it from the assertions I will make later
  before(:each) do
    sut.run
  end

  it "should trigger its collaborator with the correct message" do
    collaborator.received(:send_message).called_with("Hello World").should_not be_nil
  end
 end
end

From the example above, you can see that we created the fake and did not need to scaffold it with any behaviour.

let(:collaborator){fake}

You can also see that we are create our System Under Test (sut) and provide it the collaborator:

let(:sut){ItemToTest.new(collaborator)}

We then proceed to invoke the method on the component we are testing

before(:each) do
  sut.run
end

Last but not least, we verify that our collaborator was invoked and with the right arguments:

it "should trigger its collaborator with the correct message" do
  collaborator.received(:send_message).called_with("Hello World").should_not be_nil
end

The nice thing is we can make the assertions after the fact, as opposed to needing to do them as part of setup, which I find is a much more natural way to read things, when you need to do this style of test. Notice that the called_with method return a method_invocation that will be nil if the call was not received. My recommendation would be to create a test utility method that allows you to leverage your testing frameworks assertion library to make the above assertion more terse. The following rspec sample demonstrates:

module RSpec
  Matchers.define :have_received do|symbol,*args|
    match do|fake|
      fake.received(symbol).called_with(*args) != nil
    end
  end
end

Using the above utility method turns the previous assertion:

collaborator.received(:send_message).called_with("Hello World").should_not be_nil

To this:

collaborator.should have_received(:send_message,"Hello World")

Verifying that a call should not have been made

Currently verifying that a call was not made does not take the arguments into consideration. It just ensures that no calls to a particular named method were made. Here is an example:

class FirstCollaborator
  def send_message(message)
  end
end
class SecondCollaborator
  def send_message(message)
  end
end

class SomeItem
  def initialize
    @first = FirstCollaborator.new
    @second = SecondCollaborator.new
  end

  def first_behaviour
    @first.send_message("Hello")
  end

  def second_behaviour
    @second.send_message("World")
  end
end

describe SomeItem do
 context "when run" do
  let(:first){fake}
  let(:second){fake}

  before(:each) do
    FirstCollaborator.stub(:new).and_return(first)
    SecondCollaborator.stub(:new).and_return(second)
    @sut = SomeItem.new
  end

  before(:each) do
    @sut.first_behaviour
  end

  it "should trigger its collaborator with the correct message" do
    first.should have_received(:send_message,"Hello")
  end

  it "should not trigger its second collaborator" do
    #again, here would be another option to use a convienience test utility method
    second.never_received?(:send_message).should be_true
  end
 end
end

As you can see, in this test we want to verify that one collaborator was triggered and the other not.

As always, feel free to fork the library and send me any pull requests if you add anything interesting!!

Develop With Passion®

Bumping Up The Brussels Course By 1 Week (Due To Holiday)

2012-02-15T09:00:00-07:00

Well, it looks like the Brussels course was scheduled on a week of a national holiday!

To that end we are now bumping the course up by one week to the week of April 23rd.

Remember, if you register before the end of February and use the discount code : earlybirdforbrusselsis10 , you will receive a 10% discount off the cost of the course.

Hope to see you there!!

Develop With Passion®

Early Bird Discount For April Course In Brussels!!

2012-01-28T09:00:00-07:00

The crazy Develop With Passion® training course is coming to Brussels on April 30th!!

This is our first time in Brussels and we are excited for what the potential reception is going to be!!

You may want to consider taking the course if you are:

Able to free up their week for April 30th - May 4th.
Looking forward to spending a week with a group of peers on the continual path of mastery
Ready to come and learn killer coding techniques.
Wanting to learn principles, patterns, and practices that can help enable them to craft a path to a long lasting career as an effective developer regardless of platform or language.
Excited about the idea of 5 12 hour days of fast paced coding frenzy
Comfortable with the thought of pair programming with complete strangers to help them to increase their game!!

Registration for the course can be made here. If you register before the end of February and use the discount code: earlybirdforbrusselsis10 , you will receive a 10% discount on the course.

Looking forward to seeing you there!!

Develop With Passion®

Sharpening the sword

2011-09-30T09:00:00-06:00

The following document outlines a collection of resources which you can use to help you pursue the art of software craftsmanship.

There is a wealth of material in here that will take a significant amount of time to work through. The goal is not to complete it in a certain amount of time; rather to use the resources as a way to allow you to continually and incrementally work on honing your skills.

Some of the resources in here focus on areas related to general computer science and software engineering, others are resources that are there to help you improve more general areas of your skillset, including tuning up the old gray matter!!

Work Incrementally And Consistently

It is very important to remember that the majority of peoples brains works best when challenged consistently over a long period of time. To this end, it is important that you embed habits of daily practice into your routine. Much like it is important to commit to a workout schedule for you physical health, it is also just as important to apply the same level of discipline to the way that you train your career skill set.

The resources

Software Craftsmanship

This is really what this entire document is about, the art of crafting a long lasting career as a software professional. There is a huge wealth of information that the craftsmanship site links to. All of it is meant to give you ideas of what it means to be a software craftsman. Some of my favourites from the reading list are:

Teach yourself programming in 10 years

Lumosity - Train Your Brain - 10 minutes a day

One of the tools on this list which is specifically focused on brain training is a tool called Lumosity. This site is a collaboration between neuroscientists and computer programmers who have developed a system whereby you can increase a host of cognitive functions over the course of a prolonged training program. The initial 45 days of the program helps you establish a baseline for where you need to improve, and from that point on the program tailors itself to help you develop the skills in the areas that you need improvement.

Code Katas - It just takes 20 minutes

The following set of exercises is a collection of code katas that you can use on a daily basis to spend a small amount of time every day working on a set of problems that can allow you to work on broadening the following areas:

Increase you context pool of ideas around which to approach a particular problem
Improve your ability to craft your workbench to allow you to work in the most efficient way possible aka. Repeat katas you have already solved and try to mechanically generate the solutions faster using your favoured workbench. This will allow you to identify areas where you can see yourself using your tools in a less than optimal way and work to iron out those items.
Learn new languages. Use code katas as a way to explore a new language. Revisiting katas that you have solved and trying to implement them in as many languages as you are interested in.

Here is a small list of some katas that can keep you moving for a while:

TDD Katas These problems represent a small set of challenges that can allow you opportunity to flex you tdd programming muscles. Like any other skill, tdd is something that should be practiced over and over until you feel comfortable with the mechanics of leveraging it. In the beginning you will most likely write fairly bad tests. This is usually because TDD forces you to bring design to the forefront of your coding activity and design using code that serves as the first client of that code. Often when people get started using TDD, they are faced relatively quickly with their deficiencies in the design toolkit they thought they had. This is a great thing, as it gives you an opportunity to purposefully choose to sharpen those skills. I personally feel that the design skills you bring to the table have an impact on the way that you approach executing TDD.
Project Euler This is a set of over 350 problems that are fairly math centric in nature. This is a great resource for you to gauge where potential gaps in your math skills are. A large majority of line of business programmers can go their entire career without ever really to flex their math muscles. There is nothing wrong with this at all. Unfortunately, a large percentage of these developers also express interest in getting into other areas of computer programming, that require much higher level math that what they can currently manage. When faced with this dilemma, they can choose to close the gaps in their knowledge that will allow them to get into those areas of interest; or they will choose to go back to what they know they can do, and have a constantly nagging feeling of wanting to do more.
Using this set of codekatas, you can work through the problems one at a time, and if you hit an problem that is proving a challenge due to a gap in the math skillset, you can close that gap with Khan Academy - discussed later on !!
Code Kata One of the original code kata sites. It contains a set of problems as well as a great discussion on why to bother practicing code katas in the first place!!

Close some of the gaps in your math skill set

Khan Academy This is a fantastic resource put together primarily by the brilliant Salman Khan. Currently the site has over 2400 videos covering topics ranging from basic arithmetic to linear algebra. There are also material on history, biology. It is a crazy resource. For people who may have a gap in their math skillset, this can help you close it.
If you do happen to identify gaps in the knowledge, you have to be willing to be patient enough with yourself to go back to where the gaps stemmed from and work hard to close them. The many people out there who have been convinced by teachers,friends, etc that they are not mathematically inclined have been lied to. It may most likely mean that for you to exhibit proficiency in math, that you have to spend more time practicing and working through lots and lots of problems until it clicks.

Now of course, it should be noted that you can probably enjoy a very long and successful career as a software developer without ever needing to get into higher level math. Especially if the majority of your dev effort is spent in the line of business “crud” style realm. Of course, if you start wanting to branch out into other areas of software such as:

Machine Learning
Graphics
Neural networks

You willl definitely require the use of those higher level math skills. At that point, you will either identify that you have the skills, can refresh them, or you will have to learn them from scratch. If this is the case, I believe Khan academy can definitely equip you with the tools to get into the areas that you have interest in!!

Get a better education

A large majority of computer science based education is not really equipping programmers effectively with what I call “a solid core”. Like building a house on sand, if you don’t take the time to learn and apply the fundamentals, it will be much more difficult to adopt an attitude of confidence in your ability to tackle problems. For some of us, that means we may need to revisit topics that we never had the opportunity to cover in the school that we attended. For some that means even going back and learning about fundamentals such as basic data structures and algorithms. There is a myriad of learning resources out there that are focused on just this task, the following list is a small representation of the huge amount of options that you have to be able to use to ramp up the “core” skills:

MIT Opencourseware. For quite a number of years now MIT has been making large sections of its courses freely available for public use. Specifically for computer programmer, you can spend time looking at the Electrical Engineering and Computer Science. There is a raft of courses relating to a wide field of computer science based disciplines. My recommendation for a lot of people would be to start with the following:
To see the impact that MIT Opencourseware is having, check out the following article.
Stanford on iTunesU.

Once again, the wealth of information on here is just amazing. Even in the computer programming section alone there are lots of video lectures from topics ranging from algorithms to iphone programming.

Read some books

Books are a great resource for getting differing viewpoints on techniques and practices. My recommendation while reading books (especially technical) is to focus on active reading techniques that allow you to implement what you are reading as soon as possible. You want to give yourself the opportunity to build your own mental models for how the concepts apply, and I believe that a large majority of technical information you read is best distilled in your editor writing code and playing around with the ideas.
I have put together a small book list that I have created to focus on some fundamental areas of both software engineering and computer science. Granted it definitely leans heavier into the realm of software engineering that raw computer science, but the books that are on there are a great starting point for helping you to further the building of a solid core.
Check out the book list here:

Build a solid programming core
Build a solid core- In my opinion, the books on this list are far more important than any of the resources I have mentioned so far. Read them and prepare to have transformative things happen in your life!!

Feel free to comment on this resource list (yes comments are working again) and let me know if you think there are good additions I can make to the list of recommendations.

God Bless You.

Develop With Passion®

Review - Kinesis Advancategories Pro Keyboard

2011-09-12T09:00:00-06:00

Someone got in contact with me a couple of weeks ago asking about whether the switch I made to the Kinesis Advantage Pro was worth it? The answer is a large resounding YES!!!

This keyboard is without a doubt the most comfortable keyboard that I have ever used. For the first couple of weeks during the “adaptation” period, it was a little challenging. Getting used to the keyboard took a little bit of time, coupled with the fact that because I went “cold-turkey”, when I had to jump onto another machine to do something, I could barely type on the flat/regular natural keyboard. As it felt completely unatural compared to the Kinesis!!

The mechanics of the unit are amazing. The responsiveness of the keys, and the feel of the keys themselves are awesome. Of course, the one downside compared to my old natural keyboard, is the fact that it is not wireless. Not a biggie though.

Even though the device looks a little big, it is small enough to carry comfortably in my backpack, where I often will break it out when I am doing coding in a coffee shop (much to the bizarre looks of everyone around me!!)

The price tag may be a little steep, but to me the cost is well worth it!!

If you have been looking for a new keyboard and are willing to dish out a little bit of money, then you will definitely not go wrong with this keyboard!!!

Develop With Passion®

Keymando - Version 1.0.3 is out and a small taste of what's on the horizon!!

2011-09-09T09:00:00-06:00

Keymando version 1.0.3 is out, and we have opened up a long awaited trial mode so that people can give it a whirl. We understand that a $20 price tag for most developers is not spent lightly, so we want to make sure that people get time to play with it. For anyone who knows me and know what a keyboard freak I am, I can literally say, that I can’t even use a machine that does not have this program on it anymore!! I am going to create some small 1-2 minute screen casts that will demonstrate some of the worflows that I use on a day to day basis.

There are many constructs, algorithms and patterns that go into making this thing sing. Kevin and I are hard at work adding new features, and for now we are going to keep the lid closed on 2 awesome features that are coming down the pipe. I can say with complete confidence that it will revolutionize the way you use osx with the keyboard!!

It is also beneficial to know that we have a small, but growing, community of plugin developers who are writing freely available plugins and making them available through the official keymando plugin repository. 2 that I use quite often are the:

underscore - Great if you like to type with underscores when you code (or if you are like me, all over the place!!)
abbrev - An abbreviation plugin that emulates complex text expansion!!

What more OSX power users and developers need to realize, is that there is so much you can do for customization if you know how to code ruby. For regular users we are keeping the barrier to entry as low as possible and keeping the dsl as “simple” for the 80/20 rule. For developers who know ruby, well, you are really only limited by your imagination.

We are going to be adding more capabilities to the core pipeline that will be exposed to plugin developers, or just simple config scripts. So hold onto your hats!! For now we are also not focusing on any fancy user interfaces, as we are currently focusing on growing the core engine. The pretty UI’s for some of the features will come in time!!

For now, I’ll leave you with a large section of code from my current .keymandorc.rb file (the main configuration script). Keep in mind that some of the code in this file is based on the main line of development!! Hopefully most of it will be self descriptive enough for me to not need to include comments.

# Ignore the following apps
disable "Remote Desktop Connection"
disable /VirtualBox/

#commands----------------------------------------------------
launch_firefox = launch("Firefox")
quit_the_current_application = send_keys("<Cmd-q>", :description => "Quit current application",:remember => true)
vimperator_pass_through_mode = send_keys("<Shift-Escape>")
gmail_send_new_mail = send_keys("<Shift-Tab>" * 6)
gmail_send_reply_mail = send_keys("<Shift-Tab>" * 5)
gmail_discard_new_mail = send_keys("<Shift-Tab>" * 4)
gmail_discard_reply_mail = send_keys("<Shift-Tab>" * 3)
screen_flow_stop_recording = send_keys("<Cmd-Shift-2>")
window_hide_current = send_keys("<Cmd-w>")
#end_commands----------------------------------------------------

#----------------------------------------
#core_shortcuts
#----------------------------------------
toggle "<Cmd-9>"
map "<Cmd-d>","<Cmd-Shift-Tab>"
map "<Cmd-e>", "<Escape>"
map "<Cmd-f>","<Cmd-Tab>"
map "<Cmd-h>", "<Left>"
map "<Cmd-j>", "<Down>"
map "<Cmd-k>", "<Up>"
map "<Cmd-l>", "<Right>"
map "<Cmd-m>", "<Tab>"
map "<Cmd-,>", "<Shift-Tab>"
map "<Cmd-n>", "<Ctrl-n>"
map "<Cmd-r>", RightClick.instance
map "<Cmd-0>", "<Cmd-Shift-D>"
map "<Cmd-c>",RunLastCommand.instance
map "<Cmd- >", launch_quicksilver

# end_core_shortcuts---------------------

#mnemonic_mappings-----------------------
@window_management= {
    "wm" => mercury_mover_move_window,
    "wfs" => Divvy.full_screen,
    "wtl" => Divvy.top_left,
    "wtr" => Divvy.top_right,
    "wbl" => Divvy.bottom_left,
    "wbr" => Divvy.bottom_right,
    "wl" => Divvy.left,
    "wr" => Divvy.right,
    "wt" => Divvy.top,
    "wb" => Divvy.bottom,
    "wc" => Divvy.center,
    "w" => window_hide_current
  }

@itunes = {
  "iiv" => itunes_increase_volume,
  "div" => itunes_decrease_volume,
  "bt" => itunes_browse_tracks
}

@firefox = {
  "fi" => launch_firefox,
  "pp" => vimperator_pass_through_mode
}


@quicksilver ={
  "mi" => show_current_menu_items,
  "wi" => show_current_app_windows
}

@gmail ={
  "msn" => gmail_send_new_mail ,
  "msr" => gmail_send_reply_mail,
  "mdn" => gmail_send_reply_mail,
  "mdr" => gmail_discard_reply_mail
}

@skype ={
  "sl" => skype_login,
  "scp" => skype_call_phones
}

@sound = {
  "sts" => switch_to_speakers,
  "sti" => switch_to_imic
}

@general_mappings = {
  "aa" => app_code_all_items,
  "rel" => reload_configuration,
  "ls" => lock_the_screen,
  "x" => quit_the_current_application,
  "gmm" => gotomeeting_mute_me,
  "sr" => screen_flow_stop_recording,
  "ntt" => things_new_task,
  "jj" => RunHistoryItem.instance
}
#end_mnemonic_mappings------------------------------------------------------------

map "<Cmd-y>" do
  input(@general_mappings
         .merge(@window_management)
         .merge(@itunes)
         .merge(@firefox)
         .merge(@quicksilver)
         .merge(@gmail)
         .merge(@skype)
         .merge(@sound)
        )
end

Happy keyboarding!!

Develop With Passion®

Switching between multiple twitter accounts with TwitVim

2011-09-05T09:00:00-06:00

For the last couple of years now, I have been making use of TwitVim to twitter from within vim. Seeing how much time I actually spend on twitter, it has been a good fit and enables me to help maintain focus without getting drowned out by the twitterverse. Plus I’m a vim freak, so the more I can use it for the better.

I often have to switch between posting/reading from multiple twitter accounts. In order to do this effectively, I came up with a quick hack to allow me to switch rapidly.

Under my [devtools] folder I have an automation folder that contains a bunch of automation scripts that I have accumulated over the years. Under there I have my vim folder, here is the screenshot:

Uploaded with Skitch!

As you can see, each of my OAuth tokens for the respective user accounts is stored in this folder. The twitvim script, is trivial ruby script to copy the appropriate token into the place where TwitVim looks for the token to do Twitter authentication:

#!/usr/bin/env ruby

twitter_user = ARGV[0]

Dir.chdir(File.dirname(__FILE__)) do
  `cp #{twitter_user}.twitvim.token ~/.twitvim.token`
end

Currently I can run this script passing in the account I want to switch to and startup vim and twitter using that account!!

What I want to be able to do is call this script from inside of Vim as so:

vim

function! Switch_twitter_user(user)
  ResetLoginTwitter
  let user_name = a:user
  let switch_command = "twitvim ".user_name.""
  .!switch_command
endfunction

Only problem I am having is a bit of trouble with the last line of the function (shelling out with the command, I can’t seem to get the substitution working correctly). I am just blasting this down right now, so, if anyone knows it would be greatly appreciated. That is literally the first vim script method I have written!!

That small wrinkle aside. You can be inside vim issue the ResetLoginTwitter command and then manually shell out to the twitvim script passing the correct username and you can carry on twittering on the different account.

Hope this helps!!

Develop With Passion®

The Journey To Test-Driven: A Startup Tale - Take The Survey

2011-08-31T09:00:00-06:00

In 2 hours Mike Iwasiow will be giving a webinar on the impact of TDD for his startup.

If you have time please take the following survey:

We are extremely interested in what your teams are doing!!

Develop With Passion®

My Birthday Present Discount To You!!!

2011-08-27T08:00:00-06:00

Hey everyone, today is my birthday, and I am feeling generous!!

To anyone who is thinking about attending one of the upcoming Develop With Passion® bootcamps in either:

If you register before September 30th, 2011 and use the discount code early_bird you will receive the following discounts off the registration fee:

Medicine Hat - $500 CAD off.
Edmonton - $1000 CAD off.

Develop With Passion®