To resize the image, start by resizing the image and giving it an extra 2GB (this is run on the host):

> qemu-img resize 2013-05-29-wheezy-armel.img +2G

Now boot into Raspbian and issue the following to resize the partition (from within linux):

1. > sudo fdisk /dev/sda
2. Print the partition table ("p"). Take note of the starting block of the main partition
3. Delete the main partition ("d"). Should be partition 2.
4. Create (n)ew partition. (P)rimary. Position (2)
5. Start block should be the same as start block from the original partition
6. Size should be the full size of the image file (just press "enter")
7. Now write the partition table (w)
8. Reboot (shutdown -r now). After reboot,
9. > sudo resize2fs /dev/sda2

When that’s all done, run “df -h” and you should have plenty of space.

$ git describe --tags --long --match v*
v0.3.0-0-g865eb5f

This works wonderfully well when you have a single-line commit history, as the tag for versioning is the most recent tag.

Recently, however, we switched to using Vincent Driessen’s Git branching model, which opens up a serious hole in the simple versioning system. When you prepare a hotfix release for master, you tag the hotfix branch at the point the hotfix is being applied. This has the unfortunate side-effect of screwing up the way git describe determines the “nearest” tag.

I’ve created a sample repo demonstrating this problem. If you’re not keen on grabbing the repo, follow along with the screenshot below.

Basically what we see here is a hotfix being applied for release v0.1.0 while development continues on v0.2.0. The hotfix is merged back into develop (but decided not to be merged into master as the hotfix could wait until the next release).

Running the git-describe command above *SHOULD* yield v0.2.0-4-gba68c2f as the tag for develop in order to be true, however it comes back as v0.1.1-4-gba68c2f, which leads to our builds being completely mis-versioned. (We just versioned 0.2.0 code as 0.1.1 – how shit are we?)

Okay, so why is git picking up my v0.1.1 tag instead of the v0.2.0 tag? Turns out it has a lot to do with the explanation of how git-describe works:

If multiple tags were found during the walk then the tag which has the fewest commits different from the input committish will be selected and output. Here fewest commits different is defined as the number of commits which would be shown by git log tag..input will be the smallest number of commits possible.

Which is all well and good, however the describe algorithm ended up traversing a merge-branch down from develop and erroneously (for our purposes) finding v0.1.1 because it was closer to HEAD than v0.2.0 (well specifically in this example case they have the same number of commits, but the depth of the merged branch seems to be more appealing to git)

Digging around a bit more, I found that the git log command actually has an argument to have git-log search only the first (oldest) of multiple parent commits (ie: merges). enter –first-parent

Follow only the first parent commit upon seeing a merge commit. This option can give a better overview when viewing the evolution of a particular topic branch, because merges into a topic branch tend to be only about adjusting to updated upstream from time to time, and this option allows you to ignore the individual commits brought in to your history by such a merge.

…and when you use that to find the appropriate tag, it does!
$ git log --oneline --decorate=short --first-parent | grep '(tag:' | head -n1
b4aa13c (tag: v0.2.0) continued work on develop

So first-parent history search behaviour is what I want, but it’s not available on git-describe. Turns out, i’m not the only one who’s come across this…It’s a shame, really because describe does everything else perfectly, except for the algorithm to find the closest tag.

Unfortunately there’s no clear work-around or even a solution as to when a –first-parent argument will be made available for git-describe, which meant I had to come up with this monstrous flake of rake script to get the build version identifier (formatting doesn’t do it justice):

def git_version_identifier
  tag_number = `git log --oneline --decorate=short --first-parent | grep '(tag:' | head -n1`

  version_number = /v(\d+)\.(\d+)\.(\d+)/.match(tag_number)

  `git describe --tags --long --match #{version_number}`.chomp
end

which (in a nutshell):

1. Finds the appropriate tag number for the current branch as per the bash-fu you saw earlier
2. Parses the previous output for the tag identifier (vx.x.x as per our convention)
3. Fires THAT tag id into git describe to get it to generate the identifier properly, bypassing its search mechanism

Seems convoluted and i’m not really happy with the result. Hoping that someone out there knows something I dont.

More recently I became the custodian of an older generation MacBook Pro as a challenge to see how much of my life could transport over to OSX from Windows. One of the things I wanted to make sure of was that (at the very least) I managed to keep a backup of all my open tabs, should the shit hit the fan and a dev build of Chrome for Mac bit the proverbial. The nice thing about Chrome is that when your normal life is replaced with a gLife, you can sync all your bookmarks with big brother and they’ll keep them around for you to access anywhere.

So after a few tweets and pointers in the right direction, I learned that Mac has long had this thing called AppleScript – basically a language which can be used to automate any part of the operating system and programs which it hosts. After a lot of googling, reading help files and finding the incredibly useful Ukelele i managed to scrounge together the following script (saved here in case i ever need it again)

tell application "Google Chrome" to activate
tell application "System Events"
	-- bookmark all tabs
	keystroke "d" using {command down, shift down}
	tell application process "Google Chrome"
		repeat until sheet 1 of window 1 exists
		end repeat
	end tell
	
	keystroke ((current date) as string)
	
	-- tab to bookmark folder list
	key code 48
	
	keystroke "Other"
	key code 124 -- retain focus on "Other..." folder
	key code 125 -- down arrow for "Tabs" subfolder
	
	keystroke return
end tell

It’s not a highly dynamic or robust script, but then again nor does it need to be – it’s running in a controlled environment and does the job of what I need (near) perfectly well.

Scheduled an iCal event to execute the script at 1am, and hey presto i’m happy to be playing around on the edge once more.

Notice in a previous paragraph I said the script is near perfect. One of the limitations of AppleScript is that its higher-level functions require a library of commands to be built into any application you intend on scripting. Currently, the script library for Chrome is pretty average, so everything has to be done by simulating keystrokes. The only thing I can’t do (or at least couldn’t immediately see how to do) was to prune old backups – the only way I’ve found I could do this was to highlight the bookmark folder from the bookmarks bar and right-click to delete.

Either way, im happy with the result, and it’s another language I can add to my arsenal.

sh.exe": [: too many arguments

The code in question was:

j () {
if [ -z $3 ]; then
echo jira --action progressIssue --issue "$1" --step "$2";
...
...

It turns out the problem was that the variable $3 in the second line was being substituted directly into the if statement, without being quote delimited. So Bash is treating any input in $3 with spaces as multiple arguments (hence the “too many arguments” error). Duh.

Solution is to quote the $3 variable in the conditional to treat it as a single argument. Shouldn’t make this mistake again…

If you’re connecting your Network Space via USB, I imagine the device works out of the box. i.e. you just connect it to the Mac and Time Machine will find the drive and use it. In my case, my Network Space is connected to a wireless router, and I wanted to use it as if it was a Time Capsule.

Ordinarily, when you try and set up a Time Capsule, Time Machine will try and search for the Time Capsule over Bonjour, but because the Network Space doesnt identify itself as a Time Capsule it doesnt show up in the list. As it turns out, you can still do this, but you first need to tell Mac to chill out and show Time Machine capable devices which AREN’T the Time Capsule. In Terminal:

defaults write com.apple.systempreferences TMShowUnsupportedNetworkVolumes 1

Now, when you “Show Supported Devices” in Time Machine, the OpenShare share is discovered and you’re good to go.

Well here’s a command-line replacement i’ve devised for gitk which does a reasonable job at visualising a project tree.

git log --oneline --decorate=full --graph --remotes

Sick.

Basically what we’re talking about here is a standard, off-the-shelf drill with two operating modes: Drill mode and Impact/Hammer mode

Without getting into the detail of why you need two drill modes, the point remains that the drill itself contains a switch to flick between both modes.

(click the image to see a bigger version)

So the question is – which way do you need to flick the switch in order to engage hammer mode? Do you flick it right so that you can see the Hammer glyph, or do you flick it to the left so that the Hammer is covered up?

I asked a number of people this question, and interestingly NOBODY got the answer right. If you answered “flick it to the left so that the Hammer is covered up” then you got it WRONG. The switch actually needs to be flicked to the right. I cant explain why it was done like this and it seems completely counter-intuitive to me. There are much better ways of representing this modal change – the most obvious being if the glyphs themselves were shown on the side of the switch rather than at the bottom, and they swapped positions. This means the switch is then used to “engage” a particular mode, and the ambiguity is now removed by having to physically move the switch closer to the appropriate glyph.

So in the course of typing this blog-post, I thought about giving Ryobi a chance to respond and sent them a brief description of the problem and my proposed solution. Sadly I haven’t heard back from them. Shows how much they care about customer feedback in general. Ryobi fail.

At their heart, the web-apps can run in one of two modes:

1. Server-less App – All of the content required for the web-app is self-contained within the package. All code and images are stored on the local machine, and there’s no network access required by the plugin. These plugins can be installed by anyone, from anywhere
2. Hosted App – On the other hand, if you have a website/webapp already written, you can easily package up the relevant URLs, give the app a few hi-res icons and you’re good to go. The only catch here is that the only domains able to serve the extension are those registered in the app itself.

Upon finding out about this feature, I found the two default apps which come with Chrome in the %AppData%\Local\Google\Chrome\Application\<version>\Resources\* folder. Here you’ll find apps for GMail, GDocs and GCal. To install them, just open up the Extension Manager and select Load Unpacked Extension. The new icons will be shown on your New Tab screen.

Recently, i’ve become a big fan of Evernote, and have been using it a fair amount for both taking notes and just sharing content with myself across several computers. I figured it was an opportune moment to create an Evernote web-app extension for Chrome. It was pretty easy too – just whack in the right URLs and create a nice transparent icon.

Installing the plugins:

Firstly, you need to be running Chrome 6 (any build from the dev channel), so it’s immediately not suited to non-techs (at the time of writing). Secondly, you need to enable app mode in Chrome by running it with the –enable-apps command line option. Easiest way of doing this is to modify the shortcut you use to run Chrome (here’s a more detailed description of enabling apps in Chrome)

Now as a developer, it was easy for me to create this extension and install it myself. Providing it to others, however is not so simple. As mentioned previously, hosted app extensions can only be installed by downloading them from the website for which the app is written. This means to use my Evernote plugin, it would ideally need to be hosted on www.evernote.com. There are other ways though, and you can install the plugin by right-clicking the file and saving it to disk and then drag-drop the extension into Chrome from where you saved it.

Below i’ve attached the extensions for both Evernote and a quick one I whipped up for Google Reader. I’m looking forward to creating more of these

All content here is written in relation to WordPress 3.0 self-hosted

Amazingly I failed to find a single page on the net describing this problem, or how to attach any files to WordPress.

It seems that the main problem is that the Content Uploader is geared towards uploading media – GIF, PNG, JPG, PDF, DOC etc… But if you want to upload other files (eg: .ZIP files) then the uploader will error out with a very useless File type does not meet security guidelines. Try another..

The problem here is that WordPress is looking at the extension of the file, blocking the content from being uploaded, but then provides no system to update the list of allowed extensions/MIME types.

Eventually I found a plugin (pjw-mime-config) which allows you to modify the registered MIME types supported by a WordPress installation. Simply install the plugin, visit the config section (Settings -> MIME Types) and add your extension/MIME type to the list.

Except this semester. For the first time, I had students come up after the class and ask me about ReSharper, and what it did. I gave them a 5 minute whirl-wind tour of the tool, showing them the extract field/variable/method refactorings, move file refactoring, live templates and the integrated unit-testing. It seemed like they were hooked. In the weeks following, I was inspecting code they were writing on their personal computers, and noticed the ReSharper menu in the VS toolbar. Seemed like a victory! One step closer to bridging the gap between academia and industry.

This got me thinking about ways I could further motivate my students to put more effort into this subject, and had an idea of getting in touch with JetBrains to see if they’d be interested in partnering by providing a licence for ReSharper to give away to the student who performs best in the subject. The idea would be for me to dedicate 10-15 minutes at the start of my lesson to actually explain the tool to the class, why it’s important for them to use this particular tool and give them the demo to blow their metaphorical pants off. This all started to brew about 2 months ago…

Well as of last night, the first part of my plan fell into place. After long discussions with JetBrains, I’m pleased to say they’re happy to award a personal edition licence of ReSharper for C# to the best student in the class, for each semester as an ongoing initiative! I really wasn’t expecting such a committed outcome from them, but thoroughly pleased with the result!

Now all I have to do is evangelise…I figure that the students who get the best marks are the ones who have put genuine care and effort into the project, and one of them deserves to be rewarded with a tool which makes them more productive and helps them enjoy what they do more.

Just wanted to shout-out here to anyone who reads this blog and hasn’t used ReSharper – you really are missing out.

First of all – your resume and cover sheet (or equivalent thereof) is of paramount importance. Its primary goal is to introduce us and start a (mental) conversation. When you apply for a job, you’re basically telling me “I exist! I have the skills you need, and I’m the kind of person you’d like to work with”. The first part seems quite trivial, but remember I DON’T KNOW YOU and up until about 5 seconds ago YOU DIDN’T EXIST. So you want to take every possible opportunity to help me get to know you better.

Don’t tell me things I already know. In particular I don’t want you to copy-paste content from our corporate website and spew it back to me. I’m reading your resume because I want to know about you. If you want to show your great research skills, find some other way of doing it…And even if you ARE going to copy-paste at least change the content so it reads as if you wrote it from your perspective, instead of leaving it in the corporate marketing speak so commonly read (true story…)? Humour me, please?

Me personally – i’m a stickler for grammar, spelling and punctuation. If you’re submitting a resume as a Word doc, I have to assume that you’re submitting it not only to me but to a number of other people too. If you apply for 20 jobs, each of these companies have 2 people reading your resume, and each person spends 5 minutes reading it, that’s 3 hours of total reading time that your document is analysed and scrutinised. In that time, some people will be guaranteed to find spelling mistakes – and these reflect on your attention to detail. If you were writing a book that would take 3 hours to read, you’d (hopefully) put a bit of effort in to make sure that the book had minimal errors – so why would you not do the same for your 3 page resume? Which leads me nicely into the next point..

Keep your resume short. Don’t send me 50 pages. Don’t send me 10 pages. 3 pages is perfectly fine and 5 is pushing the limit. If you can’t succinctly condense your work experience into 5 pages, you’re not concentrating hard enough on telling me your best skills to suit the role we’re hiring for. I’m not interested in reading about a job you had 10 years ago where you made the best damn Cookie Man cookies in Central Plaza. Tell me about your work experience which is relevant to the job you’ve applied for.

But don’t limit yourself to just “work” experience. I’m interested in reading about your pet-projects, (software related) things that you do outside hours, and maybe even some not-so-software related. Please don’t write a 4-line paragraph extolling your abilities at feeding the ducks in your local park. Mentioning it as one of your interests gets me thinking about how you’re not just a 9-5 desk jockey, and anything more is just detracting from the goal at hand (see above).

Lying on your resume. I know a few people who quietly admit that they lie on their resume about their skills and abilities, arguing that they can always learn said technology/tool in time and no-one would ever know. Things start becoming unstuck when you don’t know, and you’re caught with your pants at your ankles struggling to explain how it is that you’re able to re-compile the Linux kernel using only a pocket knife and some paper-clips. Just don’t do it. This practice reflects badly on you when it backfires and if you do happen to “get away with it” during the hiring process, it will sooner or later reveal itself once we’re working together.

The Manager’s Guide To Technology. Here, i’m referring to a giant list of every-single technology you can think you’ve ever come in contact with, and writing it up as a “skill”. XML isn’t a skill. Nor is Microsoft Word. I’ll pat you on the back for opening a Word Document if you really want, but I won’t be using that as criteria for offering you a job. If you must, then please only list things that are genuine skills/practices. TDD, BDD, CI, whatever…If you need to explicitly mention software you’ve specialised in, then mention that separately. Whilst it might be an achievement on your part, reading hundreds of them is just noise on my part.

Be creative. Throw in a little design or layout your content differently to the standard Page template. It shows me you’re willing to give your resume some attention in order to grab mine. I like being grabbed (quote, end-quote). Besides, it’s an opportunity to show me your creativity. I wouldn’t recommend going crazy and being radical about your design – after all I still need to read it and follow it. But all things considered, being different is an advantage – you’re more likely to be remembered that way.

They’re pretty much the main ones which come to mind. I reserve the right to change this list the next time I see something stupid.

1. Students are given a programming assignment to solve, and 5 weeks to complete it
2. They look at problem at the wholistic level just to try and understand the problem
3. Start designing a UI and use all the wonderful draggy-droppy components on their forms
4. Spend 2 weeks tweaking their UI colours and text box alignments.
5. Spend 1 week hacking together some code so that their UI starts to interact
6. Spend 1 week tweaking more UI elements
7. Realise there’s only 1 week left and they are missing 30% of the functionality
8. Panic, ask for extensions, submit the assignment late, or all of those together.

After seeing this pattern over and over, I’ve tried different ways to address the problem in my classes. The first thing I tried was to verbally (and written in the student forums) express my sentiments that students should focus less on their UI upfront and try to make sure they have basic UI completeness first, all of the functionality implemented and finally come back to polish the UI. After all, I was seeing a great number of assignments come through with functionality either untested, totally broken or just altogether missing. Sadly my words seemed to fall upon deaf ears, and the quality of assignments were not up to the standard I was expecting.

Tackling this problem differently, last year I thought I’d try and introduce the concept of unit-testing, TDD and told them to think less about the upfront-design and instead focus on testing individual components of their system independently and build up to a solution. At the time, it seemed like a lot of students were receptive to the idea of unit-testing and test-upfront, but when the assignments came down, it looked like they just fell back into old habits and the quality of assignments seemed (on the whole) not much different to previous semesters’. After talking to some of them, I suspect the problem was that it became too difficult for them to manage this new “style” of writing their programs and keep up on top of their other coursework. The quickest and dirtiest appeared to work, and the mentality that this was purely just another assignment for the sake of passing uni seemed clearer than ever. I’m guilty of this attitude too, as when I was in uni it was more of a concern for me to make sure I completed the assignment as quickly as possible so I could spend quality time on other activities. The problem with the unit-test/TDD approach was that it offers little to a student in a reward system. Unit-tested software takes longer to write than it’s direct-implementation counterpart. This pays off in the long-run, but when your “long-run” is only as long as a 6 month semester, then why investing extra time? It’s a classic ROI question. What I needed was a way to motivate students to improve the quality of their code, and without the seemingly large overhead of the automated tests.

This semester i’ve shaken things up once again, and have dropped the unit-testing/TDD mantra. Instead, i’m focusing *heavily* on problem decomposition, units of work, single responsibility and class separation. If unit-testing doesn’t drive students to think about their application functionality upfront, then hopefully teaching them a way to make a large problem seem easily palatable will motivate them to start thinking code-first instead of UI-first. Introduction to the concept of having one class per file seemed quite foreign and unnecessary when I discussed it in our first class last week. That didn’t fill me with confidence. Despite that, i committed to persisting with this trend, and re-enforced the importance of responsibility separation under the guise of making code easier to understand, but more importantly giving the students a method for decomposing a problem and forming a solution. This I think has been the key, because receptiveness to the idea suddenly picked up when I demonstrated building a simple Guess The Number game using a number of small, discrete components. They saw what at first appeared to be a task far too large for a 90 minute class, but by identifying single functions (like “ask the user to guess a number” and “determine if the user guessed too high”) and tackling them one-by-one we produced a solution, and it’s final composition was easy to follow. #win.

I’d also changed my presentation style and was more boisterous than normal. (for anyone who knows me in person, this would be pretty intense). My theory was that if I captured their attention, it would provoke them to treat my class differently to any of their others. After all, if i’m putting the effort in, they would reciprocate, wouldn’t they? Well i’m pleased to say that after 2 weeks (yes it’s early days still) i’ve had more students hang around for the full class than before and most importantly, when i’ve run overtime nearly 70% of my students are staying back (up to an hour – 10pm at night) to ask questions and learn more.

It still awaits to be proven whether this approach makes a difference with their assignments, but certainly I’ve seen a rather large improvement in the participation of students. I’m attributing this to a combination of making the classes more entertaining, and slicing the content so it’s easily digested. Historically this has been pretty bad at university level. Hopefully this time i’ve hit a winning formula.

The part which bugs me the most is having to either type the full filename in order to open it in any editor, OR i have to use the mouse to clipboard the filename and then paste it onto the commandline. Just not straightforward enough.

So i knocked up a quick bash script which makes use of git’s ability to create extensions for git commands. This script issues a rebase (i also have one for merge) and will fire off my preferred editor for editing files outside Visual Studio.

#!/bin/bash
# git-resolve-rebase

git rebase $1 
modified=`git status | grep 'unmerged' | uniq`

if [ -n "$modified" ]; then
	git status | grep 'unmerged' | awk '{print $3}' | uniq | xargs -n1 e
fi

(where e is the shell-script to launch E-Text Editor

To use this extension, all i need to do is:

$ (MyBranch)> git resolve-rebase master

Ordinarily this kind of implementation would lend itself nicely to the Specification Pattern given that all information required to determine if the specification is satisfied exists on the object member being passed in at the time of evaluation. In my case, however, I had 3 conditions that the object being evaluated must not exist in 3 different lists. To give you an example the object under evaluation is a model, and this step of filtering is part of a much larger process involving running the model through a recursive algorithm. At each step of the algorithm, the model object could have

• Run through the algorithm succesfully
• Been aborted during execution of the algorithm
• Still awaiting to be executed through the algorithm

These three states are tracked by keeping 3 lists – one for each criteria. The filter that I was working on had to filter based on whether the model under evaluation was NOT in those three lists. I realise the wordiness of me explaining this doesn’t really clear the air, so lets look at some code (with relevant types changed).

This is my model:

    public class User
    {
       public bool Enabled { get; set; }
       public string Name { get; set; }
       public UserType TypeOfUser { get; set; }
    }

The code which uses my filter looks something like this. This guy will be called recursively based on the result that gets returned from here. In this case, i’m building the allValidUsersFilter.

public class ReplacementUserFinder
{
        ...ctor...fields...etc

        public User FindReplacementUser(User userToReplace, IList<User> allPossibleUsers, IList<User> usersStillToBeEvaluated, IList<User> usersAlreadyEvaluated, IList<User> usersAbortedDuringEvaluation)
        {
            var validUsers = _allValidUsersFilter.Filter(allPossibleUsers, usersStillToBeEvaluated, usersAlreadyEvaluated, usersAbortedDuringEvaluation);
            var replacementUser = _bestReplacementCandidateFinder.Find(validUsers, userToReplace);

            return replacementUser;
        }
}

and the interface for the AllValidUsersFilter – it’s purpose is to filter the list of all users to a list of potential candidates given the list of all users:

        public IList<User> Filter(IList<User> allpossibleUsers, IList<User> usersStillToBeEvaluated, IList<User> usersAlreadyEvaluated, IList<User> usersAbortedDuringEvaluation)
        {
            return allpossibleUsers.Where(x => 
                _isUserEnabledSpecification.IsSatisfiedBy(x) &&
                _isOverseasUserSpecification.IsSatisfiedBy(x) &&
                    !_isUserStillToBeEvaluatedSpecification.IsSatisfiedBy(x, usersStillToBeEvaluated) &&
                    !_isUserAlreadyEvaluatedSpecification.IsSatisfiedBy(x, usersAlreadyEvaluated) &&
                    !_isUserAbortedDuringEvaluationSpecification.IsSatisfiedBy(x, usersAbortedDuringEvaluation)
            ).ToList();
        }

The specification instances here are being ctor injected into my filter’s instance so that I can use a behavioural style assertion to check that the specification is invoked correctly by the filter.

The IsUserEnabledSpecification, and IsOverseasUserSpecification just use the well-known ISpecification interface pattern, but in order to evaluate the the other three, I had to create an IListSpecification and it feels somehow unsatisfying because the only thing different between them is that I have to pass in the list to the IsSatisfiedBy methods.

I’m not happy with this result, and we went through several different options before settling on this one purely just so we could move forward, and come back to address this later.

Hoping someone out there might have some suggestions…After writing this post, i’ve come up with another idea which would probably be cleaner…need to try it out.

To mount the VHD, open the Computer Management console (Start -> “Computer Management”). Right-click the Disk Management option in the tree and select Attach VHD.

Awesome.

patience, xerx….

To do this (under Windows 7), follow the steps below. This assumes you have formatted your machine and have a clean install of Win7 with your user account (with admin access) created.

Enable the Administrator account

This account is disabled by default and you will need to enable it in order to move your profile around.

1. Press Start, and type “Computer Management” and run the first program
2. Under Local Users and Groups\Users, you will see the Administrator account. Right-click the Administrator, select Properties. In the General tab, uncheck “Account is disabled”. Apply. Ok.
3. If you don’t know the password for the Admin account, I suggest right-clicking the Administrator and Reset Password
4. Log out of your current user account and log in as the Administrator

Enabling the Administrator account

Copy The Profile To Its New Location

Logged in as Administrator, open Windows Explorer and navigate to C:\Users\. You will see your account folder there. **Move (dont copy!)** your account folder to the new location you want. In my case, I moved it to D:\home\.

Update The Profile’s Home Folder Path

You now need to update the user account to tell it that the profile exists in a different location.

1. Press Start, and type “Computer Management” and run the first program
2. Under Local Users and Groups\Users, you will see your user account. Right-click the account, select Properties. In the Profile tab, select “Local path”, and type in the new path of the profile. (eg: D:\home\xerxes). Apply. Ok.

Profile Home Path

Update Registry To Find New Profile

I probably should have mentioned this before, but if you’re not comfortable modifying your Windows Registry, you probably shouldn’t attempt this. Moreover, you probably shouldn’t be reading my blog.

1. Start -> Run, “Regedit”, Enter
2. Find the key HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList. There will be a string value called Profiles Directory. Update the value to be your new profile home directory. (eg: D:\home)
3. Within the ProfileList key, there are a bunch of sub-keys, one for each user profile registered on the system. Scroll through them and look at the value ProfileImagePath, and find the one which mentions your username. Update the value of the ProfileImagePath to be the new path to your user profile (eg: D:\home\xerxes)

Updating User Profile Location In Registry

Fin//

You’re all done. Log out of the administrator account and try logging back into your own profile. If you did everything right, this should just work. If you want to disable the Administrator account again, you can do so after logging back into yours.

In a nutshell, the pomodoro (tomato in Italian) technique involves:

1. Pick a task and work to complete it in 25 minutes
2. Break for 5 minutes
3. Repeat steps 1 & 2 three more times (4x25min blocks + 5x5min breaks in total)
4. Have a 15 minute break

Although we’re still aiming to achieve 4 consecutive pomodoros in a row, we both have noticed the increased focus and commitment to delivering on our development tasks. The 25 minute time block actually acts as an incentive to try and complete a problem up to a logically clean point before time runs out – this has in turn helped us break the problem down into smaller tasks.

This system worked so well within the first few days of using it, we even set-up a box and screen right in the middle of our desks which (amongst other things) is used to display a big timer from the website http://tomatoi.st/. Any visitors who come to talk to us are kindly pointed to the big count-down and asked to come back at a time that’s better for us. Whilst it might seem unprofessional, we’ve yet to encounter someone who felt it important to disturb us in the middle of a timed task. There’s something about two people working diligently at a desk with a count-down over their heads that prevents others from wanting to disturb them.

What’s also nice about the tomatoi.st timer, is that it keeps track of the last 7 actions (either pomodoro or break). I whipped up a Yahoo pipe to convert the pomodoro list into an RSS feed. The purpose of the RSS feed is to at least keep historical records of how we’ve been tracking to see how whether or not we’re improving. This content could be fed into uladoo and tracked via Twitter or some other unnecessarily Web 2.0 service.

No doubt we’ll refine this process the more we work with it, but it’s been quite beneficial thusfar. I suspect a lot of other development teams will also benefit from this practice.

gitk <filename>

Yes that’s right, yours truly really screwed up this time.

For future reference (and in a nutshell), git checkout is not the same as git reset, particularly when you throw in the hard option. I know this now, and in fact I knew it when i accidentally blew away half my repository – didn’t make the end result any less pleasing.

Here’s the gitk output of what my tree looked like before the wipe:

I was intending to checkout a previous revision of the repo to show how some code had evolved over time. Normally I would do this from the command line, but this time I (crazily) chose to use (the very disabled) gitk to do this, and blindly chose the “hard” option without thinking. So what I was left with was a very lacking repository and even sorely bruised ego. Goodbye repo history! It’s been nice knowing you….

Thanks to the ever-knowledgeable davesquared, there’s a way to recover your git repo once you bone yourself. If you escape the clutches of the gitk demon, the command line interface gives you a better level of control (and content which is crawlable by search engines )

It turns out that until the repository is cleaned (git gc) and stale objects are cleared, the repo still has the necessary content stored, it’s just not visible. (if the following block looks terrible in your renderer, click through the link to read it properly.)

xerxes@laptop /d/source/dotnet/CodeKatas/.git/logs (GIT_DIR!)
$ cat HEAD
0000000000000000000000000000000000000000 f167fd4068e4b92134964e073f2e69a0cc8fced9 Xerxes  1250928395 +1000 commit (initial): Initial commit of binary search
f167fd4068e4b92134964e073f2e69a0cc8fced9 dd31afc8d793aaa952e032a77675b8e67f6b26bc Xerxes  1251007341 +1000 commit: Removedbin/obj from source control
dd31afc8d793aaa952e032a77675b8e67f6b26bc 0642a5e64a513f8949f7aa9e1d35a298fb713bfc Xerxes  1251007422 +1000 commit: removed.suo from source control
0642a5e64a513f8949f7aa9e1d35a298fb713bfc 0cf0929cfb9a31707b2ae937f0c6e73bd9e5bcb9 Xerxes  1251007479 +1000 commit: Implemented first binary tree implementation. it is shit
0cf0929cfb9a31707b2ae937f0c6e73bd9e5bcb9 6c27c54370bf2b79369dc5ef02ef7338bbf2865a Xerxes  1251010817 +1000 commit: Refactored first implementation to remove unnecessary elements
6c27c54370bf2b79369dc5ef02ef7338bbf2865a 937fcb1c36bf437e0df11847ee579ca60151144d Xerxes  1251021898 +1000 commit: removedresharper settings file from project
937fcb1c36bf437e0df11847ee579ca60151144d b12a95ea3c636615345559979d3fc0e93fecc0bc Xerxes  1251022036 +1000 commit: Rewritten first implementation of b-search to get practice.
b12a95ea3c636615345559979d3fc0e93fecc0bc f57503a6116822c9632e6b4dc6cb423640c6a152 Xerxes  1251028214 +1000 commit: 3rd implementation of binary search using shifted bounds.
f57503a6116822c9632e6b4dc6cb423640c6a152 be510f0f88baa38d8d2e645f568405d052f5bb14 Xerxes  1251028265 +1000 commit (amend):Another rewrite of binary search using shifted bounds.
be510f0f88baa38d8d2e645f568405d052f5bb14 2c0b21e7aea2dd27fc7281d1a20a887e2e1f3d0d Xerxes  1251090393 +1000 commit: Yet another re-write of the shifted boundary method.
2c0b21e7aea2dd27fc7281d1a20a887e2e1f3d0d d2a23e1cad8b36de1361700b89733a3b08401e2c Xerxes  1251253854 +1000 commit: Moved BinaryTree project to top-level folder
d2a23e1cad8b36de1361700b89733a3b08401e2c 4e8bd70336e89f9000f29553d53d98cb568bc809 Xerxes  1251253901 +1000 commit: Added nunit to the list of dependencies
4e8bd70336e89f9000f29553d53d98cb568bc809 551c754f27f10826dab43c50d8a3151b7e2740f5 Xerxes  1251253922 +1000 commit: Implemented FizzBuzz
551c754f27f10826dab43c50d8a3151b7e2740f5 11884f5935c85d4ec1497fe3a8eb39211d731fdc Xerxes  1251269688 +1000 commit (amend):Moved parameters onto FizzBuzz method and out of constructor
11884f5935c85d4ec1497fe3a8eb39211d731fdc cbda7a8c68c88900eb1c58ab7bf613bad26892ad Xerxes  1251269732 +1000 commit (amend):Implemented FizzBuzz solution
cbda7a8c68c88900eb1c58ab7bf613bad26892ad b40c951696a2d11854fce6a9fca1be9fc436e61b Xerxes  1251341643 +1000 commit: Anotherre-implementation of the shifted-boundaries method
b40c951696a2d11854fce6a9fca1be9fc436e61b b2c2a8b103aa43dac8e443cfc866fa35f9ffb048 Xerxes  1251341967 +1000 commit: RenamedBinarySearch to ShiftedBoundariesBinarySearch
b2c2a8b103aa43dac8e443cfc866fa35f9ffb048 30a224eb40c441df8a18b06eeb68af47a86bc37f Xerxes  1251344036 +1000 commit: Implemented RecursiveBinarySearch (badly). requires refactor
30a224eb40c441df8a18b06eeb68af47a86bc37f 0fbf8ace753f408b0e972b593e2b6a03dd2d0354 Xerxes  1251345463 +1000 commit: CreatedTreeNode Search
0fbf8ace753f408b0e972b593e2b6a03dd2d0354 0cf0929cfb9a31707b2ae937f0c6e73bd9e5bcb9 Xerxes  1251345505 +1000 0cf0929cfb9a31707b2ae937f0c6e73bd9e5bcb9: updating HEAD
0cf0929cfb9a31707b2ae937f0c6e73bd9e5bcb9 2c0b21e7aea2dd27fc7281d1a20a887e2e1f3d0d Xerxes  1251345635 +1000 checkout: moving from master to 2c0b2

xerxes@laptop /d/source/dotnet/CodeKatas/.git/logs (GIT_DIR!)
$ 

The beauty here is that the log has kept full record of all the SHAs for each commit in the repo. NOW i’m able to reset my master back to the appropriate commit by using the SHA-1 hash. So i checked out onto the master branch and issued:

xerxes@laptop /d/source/dotnet/CodeKatas (master)
$ git reset --hard 0fbf8ace753f408b0e972b593e2b6a03dd2d0354 

and that reset my master back to the right revision, thereby restoring my history, code and sanity.

nb: i have taken some of these screenshots trying to reproduce after the event, so they might look a little doctored. Despite this, the findings and end results are the same.