Ice Breaker: The story of my sprint

Retrospective icebreakers can serve more than one purpose. On one hand you are looking to break down barriers and encourage the team to communicate (which will pay dividends in the retrospective that follows the icebreaker), but you can also use the icebreaker to help people focus on what happened over the last sprint.

With this as my aim, I created an icebreaker that worked out so well, that I thought I had to share it.

The Story of My Sprint

Synopsis: 

Around a table, get people working in pairs to add a story to a comic strip in order to represent the sprint (or an aspect of the sprint) that they have just completed. 

After this is done, the pairs read out their comic to the group. It is important that all of the pairs are given the same comic strip so that you can appreciate the different stories that the pairings are applying to the same illustrations.

Duration: 5-10mins

Example: Below are the results of this ice-breaker from my scrum team

Instructions : Prep Work

1. Find a comic strip which has enough panels to fill a single sheet of A4 with enough room in the gutters for dialogue or descriptions to be written. Feel free to choose something obscure so the team writes their own story as opposed to regurgitating a known dialog. (the example I used was from 'One Punch Man').
2. Edit out any existing text and dialogue. (This allows people to add their own dialogue and framing without being constrained by the 'original' story that the comic strip conveyed)
3. Print your comic strip onto A4 so that you have enough for every 2 people in the scrum team (print some spare just in case, but keep them out of sight unless they are needed).
4. Make sure you have plenty of pens!!

Instructions : The Session

1. Place several copies of the comic strip onto the table, and let the team know what they are looking at. If the comic strip you chose is one that you are familiar with, you get a relatively easy way of introducing it. As usual you want this exercise to appear like a natural thing to do. Don't tell the group what the 'actual story' is; if the original story was about Batman stealing a car, you may get theft as a theme to everyone's stories which would corrupt the sprint stories.
2. Ask everyone to get into pairs. You know your team best but be aware that the story should be the product of co-operation for each pair.
3. Ask the pairs to take a comic strip and a couple of pens, and try and write a story based on the sprint that has just been completed. Let them know that they have 5 mins to get their story written down. Feel free to continue your coaching and coaxing through this period; you can tell them it doesn't matter whether the story describes a single event, overall feeling or anything else, as long as it is based on the sprint. Also feel free to be quiet and allow the room to be filled with the noise of the pairs coming up with their stories. Feel free to write one yourself, this might be helpful in the next phase of this icebreaker.
4. Now that all of the stories have been written, it is time to share them. If your team are a bit reluctant, this is where having your own story comes into play. Set an example and read/narrate your story to the group, if you want your team to express them selves, this is how you set the example. Trace the story panels with your finger as you read it, this will enable the team to follow the story more easily. With the example set, ask the pairings to, in turn, read their stories out loud, with as much gusto as possible.
5. Congratulate everyone on their stories. 
6. Declare that there were some interesting things that were covered in the stories and that they might help us focus on what we feel worked well and what we may want to change as we move into the main part of the retrospective.

The End

Hopefully this pre-retrospective icebreaker works as well for you as it did for us. We found it a great way to get everyone communicating and was a fun way to remind ourselves of some of the things that happened in the sprint that may otherwise been forgotten about.

Adventures resigning an ipa with xCode 10.1 - aka arm64e causes 'Invalid Swift Support'

Re signing our ipa

I was recently in a position where we needed to re-sign an iOS app. One of my colleagues had already integrated a script into our TFS build process for handling this: github.com/huhuvipi/VH_ipa_packger However we also wanted to ensure that we will be using the same version of support libraries in our package as we have available when we do the signing, so in the loop we also copy the support files from xCode into our app too.


cp -f "${DEVELOPER_DIR}/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphoneos/${SWIFT_LIB}" "${APP}/Frameworks/${SWIFT_LIB}"

Impact of xCode 10.1

This had been fine until our most recent submission, where we got the following error uploading through App Store Connect:

We identified one or more issues with a recent delivery for your app, "XXX". Please correct the following issues, then upload again.
Invalid Swift Support - The files libswiftCore.dylib, ..., ..., etc. don’t match /Payload/XXX.app/Frameworks/libswiftCore.dylib, ..., ..., etc. Make sure the files are correct, rebuild your app, and resubmit it. Don’t apply post-processing to /Payload/XXX.app/Frameworks/libswiftCore.dylib, ..., ..., etc

One of the things that had changed since our last submission was the version of xCode that we were using. A review of the release notes revealed the following; XCode 10.1 now contains support for a preview of the arm64e architecture but carries the following warning:

The App Store and TestFlight don't accept submissions containing arm64e. xCode will remove arm64e content from your app when you distribute from the Organizer window. (42296212)

Because our continuous integration pipeline pulls the support files directly from xCode, we were now unwittingly packaging arm64e as part of the support files which is not supported on submissions to the store. This consequently reports the 'Invalid Swift Support' message.

We can verify the inclusion of arm64e by interrogating the libraries using the lipo command

lipo -info "${DEVELOPER_DIR}/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphoneos/${SWIFT_LIB}"

more information on lipo can be found here

Removing the unsupported arm64e architecture

Now we know that we are not allowed to upload arm64e support, and that xCode would normally omit this from the release on our behalf, we can simply do the same and strip the unwanted architecture from the libraries that we are using.

To do this, instead of copying the support files out of xCode we could output the support files with the unsupported architecture removed. ie:
 
lipo "${DEVELOPER_DIR}/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphoneos/${SWIFT_LIB}" -remove arm64e -output "${TEMP_IPA_BUILT}/SwiftSupport/${SWIFT_LIB}"
and
lipo "${DEVELOPER_DIR}/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphoneos/${SWIFT_LIB}" -remove arm64e -output "${APP}/Frameworks/${SWIFT_LIB}"

We are now able to submit our app successfully as before.

Finally

When arm64e is supported we can revert back to copying the full support library or we could spin this around and explicitly declare the support we want contained within our swift support libraries.

Most importantly, we can continue signing and submitting our app. Which is nice.

The Continuous Delivery Maturity Matrix

The Continuous Delivery Maturity Matrix is a yardstick which against which you can measure your current processes. Ultimately this equates to how well you are able to deliver your projects.

Why is this a good thing? Well, once something is measurable, it is actionable.

The Matrix is split into rows (Quality Levels) and Columns (Aspects of Delivery). You should be able to give a Quality level for each Aspect based on your current development life-cycle. This can help us to understand where our weak points are, or why we may be unable to deliver consistently.

Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation
by Jez Humble and David Farley

The following is an extract from a piece that I wrote in 2012.

Delivery had been a big problem for us, but the matrix helped us to understand how we could make the delivery process more reliable and robust. I took a copy of the matrix and marked where we were against it (see above). Something had to change, and the matrix helped us to identify the adjustments that we we could make and also helped us to use an appropriate language with our line managers. Where we were regressive, we would take action to become repeatable. Where we were repeatable, we would take action to become consistent, etc.

Our improvement would not have happened without measuring against this matrix. It is my belief that after every project delivery we should grade ourselves against this matrix as part of the project review, learn the cause of failure and create actions to address this in subsequent project deliveries.

Please take a moment, have a think about your latest project delivery, grade against the matrix, and have a think of how it could have been less painful.

Remember, when it comes to software delivery: "If it hurts. Do it more frequently".
Understand the pain and address it.

Two books that should be on your book shelf.
Continuous Delivery
Continuous Integration

Moving Xamarin's Android dependencies off your Primary drive

The other day I wanted to get the latest android SDK, but due to insufficient space on my primary drive this failed.

What follows is the process by which you can get from this situation into one where you can have as many SDKs and Android Virtual Devices as you want (as long as you have somewhere other than your primary drive to park it).

First, make sure you are fixing the right problem.

Just because our drive is too full to accommodate any more SDK artifacts or create a new AVD, that doesn't mean they themselves are to blame. So let's find out before we go any further.

Running a utilities like WinDirStat, TreeSize (etc) will quickly show you what your disk fillers are.
For me the biggest culprits were the android SDK and my AVD's (hence the blog post).

Moving the SDKs

Moving the SDKs is pretty straight forwards, in your IDE you will find the settings for Xamarin, including the location of the Android SDK's.

Visual Studio - Options menu.

• Go to this location and copy the Android folder (containing the SDKs) to your secondary drive.
• Update the reference in your IDE.

Once done, you should see that when you open your 'SDK manager'. The being used should now be the new one that you defined in the previous step.

• Delete the original Android SDK folder from your primary drive, to free up some space.

Moving the AVDs

Let's see if we can make more room by moving those AVD files...

• Add the following key to your environment variables
  ANDROID_SDK_HOME
• Assign it a value of where you would like your .android folder to live, eg.
  F:\AndroidDevices

If you want to use your existing devices, copy your existing .android folder from your primary drive to this location.

This variable will kick in after a restart.
You can verify that this change has been applied by Opening your AVD manager from Visual Studio and looking at the address at the top line.

The NDC Experience

Back in January, I was lucky enough to go to NDC in London.
http://ndc-london.com/

This was a great experience, and one that I would recommend to any of my colleagues. So, to give them an idea of what it was all about, I gave a presentation on it. This presentation, including a Q&A session, lasted for 45mins, and was designed to pass on what I learned from going to NDC. It wasn't recorded, but I'm happy to share the slideshow (link below).
http://bit.ly/1ShIbV1

It was also a nice opportunity to use Prezi

Send me a picture, so I can remember

Retrospectives

Sprint retrospectives are important. This may sound like I'm stating the obvious but please make sure that you have concise retrospectives.

The big benefits of a good retrospective include

• Getting honest feedback on the progress of your project. 
• Gauging the teams mental state. 
• Strengthening relationships between the team members (after all, we are in this together).

If you are organising the retrospective, your biggest job is to help people to give open feedback. You can do this by creating an environment in which they are comfortable and giving them tasks that help elicit the information as opposed to directly asking for feedback on the sprint.

The following exercise describes one of the methods for garnering feedback.

Postcards from the Sprint

• Before the retrospective

1. Get (or make*) some postcards. Try to use a wide selection of destinations, 10 postcards of the east coast is not a good selection. 
2. Get (or make**) some tokens. Make sure that these are easily identifiable (eg. Monopoly pieces).

• In the Retrospective

1. Ask all member of the retrospective to choose a token.
2. Spread out the post cards on a flat surface.
3. Ask the members of the retrospective to place their token onto the postcard that they 'feel' represents the sprint that we have just completed.
       - Wait for everyone to place their token - 
4. Choose a token (not a person***) and ask who that token belongs to. Ask that person to describe in what way they feel that that postcard represented the sprint.
5. Remember to say thank you. 

Why is this a good exercise

• The postcards act as a starting point, whether that it is an association to the place, geography or a metaphor, the person is grounded by the selected image and merely needs describe a context.
• Everyone gets to express an uninterrupted opinion and comment on the sprint.
• The tokens are ambiguous, and therefore the running order is random.
• Members choices are 'locked in' so there is no playing follow the leader when they are expressing their feeling.

Retrospectives should not feel like a chore and it is not a cull-able step in the process. So keeping people engaged at this stage is important. we've managed it all sprint and by Jove we'll keep them engaged in the retrospectives too!!

* How to make a postcard: Find a royalty free picture, resize it, print it, cut it out, laminate it.
** How to make a token: (see 'How to make a postcard' above).
*** Not a person: We want to disassociate any feeling of singling out, identifying or alienating individuals when eliciting unbiased feedback, hence the tokens.

When is a valid win32 application, not a valid win32 application

What happened

Recently I've needed to upgrade an application to use 4.0.3 of the .Net Framework. The upshot of this was that the application was no longer XP compatible.

Not a valid win32 application

This was un-expected, there isn't a compatibility issue with XP and this version of the framework. However, upon inspection, the compiler had marked the application as being for Vista OS onwards. Explicitly set this to XP and the application is once more a valid win32 application.

SUCCESS!!

This is how it was done.

1. We inspected the application.exe header using dumpbin. This is a Visual Studio command line utility.
2. Here we could see that it was targeting /subsystemversion 6.00 which is Vista, considering the change we made, this is neither desired or required. Ideally we would ask the compiler to mark this correctly for us, but msBuild doesn't expose this switch. So instead we would need to change this post compilation.
3. So we added a build step to adjust this flag after compilation. For this we used editbin. Another Visual Studio command line utility. To set the
   
   editbin.exe "$(TargetPath)" /SUBSYSTEM:WINDOWS,5.01 /OSVERSION:5.1

DumpBin
You can use DUMPBIN to examine COFF object files, standard libraries of COFF objects, executable files, and dynamic-link libraries (DLLs). You can start this tool only from the Visual Studio command prompt. You cannot start it from a system command prompt or from File Explorer.
https://msdn.microsoft.com/en-us/library/c1h23y6c.aspx

EditBin
You can use EDITBIN to modify object files, executable files, and dynamic-link libraries (DLL). You can start this tool only from the Visual Studio command prompt. You cannot start it from a system command prompt or from File Explorer.
https://msdn.microsoft.com/en-us/library/xd3shwhf.aspx

/subsystemversion

Specifies the minimum version of the subsystem on which the generated executable file can run, thereby determining the versions of Windows on which the executable file can run.

Specifies the execution environment that's required by the executable image.

https://msdn.microsoft.com/en-us/library/yaks5w33.aspx

 

Setting up

Whether you are setting up a development workstation or swapping jobs, you probably want to make sure that you have all of the gadgets and utilities that make your work life easier which may not be on the default machine image supplied to you.

That is where posts like this come in. You'll find that most development blogs will have a post of this nature, where the author lists some of the cheap or free productivity tools that they have found useful.

Here is my list.

Notepad++

www.notepad-plus-plus.org
It's like notepad but better; tabs, tab persistence between sessions, find in all tabs, and that's just the tabs!! You can even define your own language syntax to create custom document highlighting (if you want).

Unlocker

http://filehippo.com
Resolve sharing violations by removing a troublesome lock that another process has on that file. For example: "Hmm, I can't delete this folder, and even though nothing and no-one should be using it." - Unlocker to the rescue, albeit a dangerous and crude one. If this sounds abhorrent, try investigating the issue using ProcessExplorer (mentioned later in this post).

F12

Okay so you'll have this one already, but non-web-devs often forget about it. Press F12 when you are using your web browser and you'll find a whole range of tools here for the web developer. From performance monitoring to browser emulation, JavaScript debugging and CSS editing. There are so many useful items in here that people often neglect.

ORCA

https://msdn.microsoft.com/en-us/library/aa370557(v=vs.85).aspx
Provides a GUI for Windows Installer packages. Not only does this tool highlight validation issues, it also allows you to edit and save the new package.

WILogUtl

https://msdn.microsoft.com/en-us/library/aa372811(v=vs.85).aspx
This tool will parse your Windows Installer log files to help you identify issues with the installation and suggest solutions. It beats the hell out of searching for 'Return Value 3'

Kaxaml

www.kaxaml.com
A lightweight XAML WYSIWYG editor. Keep things simple.

7Zip

www.7-zip.org
Compresses to 7z, TAR, ZIP and more, Extracts from 7z, TAR, ZIPm RAR and many more. If you've never tried it, run a comparison between the compression ratio of 7z compared to ZIP, you'll be pleasantly surprised,

ReSharper

www.jetbrains.com/resharper
This is a great productivity tool. It'll be interesting to see how quickly the new .net compiler helps the Visual Studio community close the gap, but at the moment you'll want to be using this plugin.

DotNetPeek

www.jetbrains.com/decompiler/download
Decompile dot Net assemblies to C#. Sometimes we all get a little bit nosey.

BareGrep

www.baremetalsoft.com/baregrep
Historically the Microsoft Windows search isn't very good, but this flexible tool will quickly search for files matching your search pattern.

BareTail

www.baremetalsoft.com/baretail
Another from BareMetal Software, this time a log file parser. This tool will show log entries in real time, highlighting different types of entries based on keywords.

ASoft - DotNetVersion

http://www.asoft.be/prod_netver.html
An easy way to find out what versions of .net are being used on a client machine. The beauty of this tool is that the clean interface means that any tom, dick or harry can use it and even download missing versions directly.

KDiff3

kdiff3.sourceforge.net
An easy to use file and folder differencing tool. Run a comparison against up to three directories for differences or missing artefacts. Drill into files to analyse the differences.

ProcessExplorer

https://technet.microsoft.com/en-gb/sysinternals
Find out about a process currently running on your system. Target processes with the cross-hair or search the running processes to find out the ID of your target process, and what resources they are using on you current system. If you didn't like the Unlocker utility, mentioned above, you may prefer this tool as a means for finding what process has a lock on your file.

PowerGUI

en.community.dell.com/techcenter/powergui/m/bits/20439049
Create and manage powershell scripts

And if that list has whet your appetite; checkout Scott Hanselman's list, it's much better than this one :)

All items listed are downloaded and used at your own risk. I have not been involved in the creation or hosting of any of these utilities and cannot make any guarantees over there safety. Please review all terms and conditions on the named applications and licensing before installing.

Sorry about that...

I decided to change employers, which has kept me a little bit busy.
Now that is done, and I'm settled in, I'll continue blogging.

ps. If you're voting today, vote for the good guys.

It's a wonderful life

Reflection is important in many aspects of life. When we complete a project, when a new year begins and when we unwind with friends and colleagues. We reflect on events as a means to make sense of them, learn from them and move on from them.

As software engineers we are conscious of reflection as part of the Application Lifecycle Management process, and I thought that I would take this opportunity to reflect on my life as a software engineer.

The advice that I received from my parents before I went to college and university was: "You'll be working for a long time, make sure that you do something that you enjoy". This advice stayed with me. There where times when it seemed like it was bad advice, but I can look back over the last 15 years and say that I enjoy what I do as much as ever.

I'm a practical and creative person, and I have at my finger tips the means to create anything that I could want, Applications, Games, Data Visualization. I share these interests with friends and colleagues that make me want to be more than I am. And although a lot of my friends don't actually understand what I do and don't see what could be enjoyable in it, that's okay, 'not everyone's like you'*.

I chose to do what I enjoy, and I enjoy what I do. And on reflection, It's a wonderful life.

At DDDNorth with some likeminded people.

* 'In the mood for love' - http://www.imdb.com/title/tt0118694/

From Meetings to Success

It can be all too easy for a projects user stories to be copied and pasted directly from the annotated minutes of a meeting where 'stuff' was discussed and declared. These stories tend towards suggested implementation. When this happens, the odds are that the structure (and requirements) will not be clear.

 

Pragmatic analysis and Clarity are key to Success.

 
When pulling stories from meeting minutes you'll end up with the flattening out of data producing spaghetti requirements, leading to spaghetti code. Based on the muddy stories, a hotch potch of testing will be produced, proving a risk to the  successful delivery of items buried (or missed) in the documentation.

 

Lets make the change.

 

Consider the following structre when writing user stories:

 

A User Story should be designed as follows:

As a …

I want …

So that …

This describes the need of the change.

 

These stories can then have Acceptance Tests in the form of:

Given …

When …

Then …

This describes the behaviour of the change.

 

Once we understand the behavioural change required, then we can work out what tasks are required to make the behavioural change. Once all of these tasks are completed then the Acceptance Tests should pass, the story will be resolved and importantly, all of that stuff that was declared in the meeting can be put to bed.

 

A successful meeting leading to a successful implementation.

It’s not you, it’s me

Motivational quotes; we hate them

A poster of a road going into the distance: "determination". 
A picture cat in a tree: "go get them".

We've seen them at training venues and on office walls. But not only can motivational messages fail to make a positive impact, they can actually make a negative one.

Maybe we see the long road “determination” motif and think; "well, that doesn't make sense... The straight road is designed as the shortest distance between two places, what's that got to do with 'determination'? Are they saying that I'm determined if I drive on what looks like a nice open road?...etc"

And regarding that cat in the tree; "I’m a dog person, so I don’t even want to see any meaning here. Stop showing me pictures of cats." *

 

A fun example of a motivational message backfiring is this post on The Poke.

http://www.thepoke.co.uk/2014/06/13/marvellous-mathematical-takedown-of-a-motivational-poster/

 

We hate motivational quotes because they are not aimed at us, they are for someone to whom this phrase or representation resonates. For us however the message and representation may not resonate, it may seem ridiculous, we may hate it.

 

Motivational quotes; we love them

A lyric from your favourite song.
A line from a memorable film.
A quote from a book.

The motivational quotes that mean something to us aren't an outside voice telling us to be 'tenacious', 'confident' or 'bold', It's our voice. Someone else may have found the words or image for what we need, but this is our message, it means something to us and therefore can motivate us.

 

Epilogue

It would be remiss of me to create a post regarding quotes and not logging a few that I like. I'm aware that you may not like them, but that's okay, as someone once said "Not everyone is like you".   

“The World is Yours Ours”

La Haine 

“When life itself seems lunatic, who knows where madness lies? Perhaps to be too practical is madness. To surrender dreams - this may be madness. To seek treasure where there is only trash. Too much sanity may be madness - and maddest of all: to see life as it is, and not as it should be!”

Man of La Mancha

“Not everyone is like you.”

In the mood for love

 

 

 

* Although I'm a dog person I actually have cats. 

Getting Started on Twitter

I love the casualness of twitter, where profundity and trivia have an equal footing. If you need a quick-start on your follow list, consider the following accounts.

@infosthetics	Data visualizations that inform and/or intrigue.
@junkcharts	Edward Tufte has declared chartjunk as an enemy of clear, informative graphics of data. Chartjunk is everywhere, particularly in mainstream
@mtaulty	I do some developer stuff for Microsoft in the UK. [[ pretentious job title goes here ]]. UK
@jonskeet	Currently a software engineer at Google, London. Usually a Microsoft MVP
@thebeebs	Microsoft technical evangelist. Currently working on mobile apps.
@YouAreCarrying	A Twitter bot by Andrew Vestal that provides a fictional adventure game inventory. Users need only tweet the bot with “i”. (users have produced some lovely pictures in responce to 'what they are carrying')
@konatsu_tunacan	Pretty Pictures
@shanselman	Scott Hanselman is a programmer, teacher, speaker, technologist, podcaster, writer, diversity advocate and more.
@Jodie_Paterson	Freelance illustrator and stationer. Owner & designer at Paper Pipit. Head of 'Charlie work'
@msdevUK	Microsoft Developer UK
@RealBobMortimer	I've just fell off my Honda .. My legs are in that tree..and yes I was wearing those shoes again.. The ones from Italy.
@codinghorror	NET programming from a human factors perspective: thoughts on software usability and effective team development.
@Loki_Coki	Design and illustration.
@boagworld	Author of Digital Adaptation. Co-Founder of @headscapeltd. Host of the Boagworld Podcast. Over 20 years of helping organisations manage digital change.
@andybudd	Andy started designing websites in 1998. He founded Clearleft with Richard Rutter and Jeremy Keith in 2005
@scottgu	Scott Guthrie is an Executive Vice President of the Cloud and Enterprise group in Microsoft. He is best known for his work on ASP.NET
@IrisClasson	.NET developer & Microsoft C# MVP
@kibooki	Those are no actual toys, but some gorgeous and creative 3D dedicated to the allmighty glory of Edgar Wright, Simon Pegg and Nick Frost.
@thoughtworks	A community of passionate individuals whose purpose is to revolutionize software design, creation and delivery, while advocating for positive social change.
@DDDNorth	Twitter account for THE premium developer event in the North of England.
@codefoster	Developer Evangelist at Microsoft. Windows 8, HTML, JavaScript coder. Hiker. Sailor. Husband. Dad. Not in that order.
@ch9	Channel 9 keeps you up to date with videos from people behind the scenes building products at Microsoft.

Managing Objectives

One of the things that I decided to improve this year is how I manage my personal development objectives. I outlined the following requirements.

• I need to manage a backlog objectives.
• I want these objectives to be broken down into tasks of a granularity that can be completed in my spare time.
• I want a task board so that I can see the tasks remaining broken into monthly sprints.
• I'll need to access to this data from any location.
• I'll want to collaborate with zangl ltd for some gaming and mobile development tasks.

 

For me, the next step was straight forward. I logged on to Visual Studio Online and created a new Team Foundation Service Project called 'Development Objectives'.

 

The interface is intuitive, the task management is straightforward, the backlog can be easily groomed and it even has a burndown chart to keep me on track.

 

My Personal Task Board

 

So far it is proving the perfect solution, get started.

Where shall I begin...

A colleague recently asked me how I start my personal coding projects. He'd love to do more projects out of work but doesn't know where to start. This post is a look back to how I first learnt how to overcome writer's block.

Where It Began

A little known fact about me is that I have a degree in fine art, specializing in oil painting.
In the first year of my degree all boundaries of what was valid were lifted. I was allowed to create anything. To do anything. What ever I wanted to do, to produce ART. But what was noble enough to be my subject? something profound? what? Before I gave any ideas a chance to formalise, I would find reasons why it wouldn't work. The product of this was that I spent the first 12 months studying the white cube, which was not only an analogy for the gallery space but also a blank canvas. 

One of my Paintings (post white cube era)

The Sketchbook 

In the end, what helped me to commit my ideas to canvas, and not to fear about them being exposed, was my sketchbook. A sketchbook is private, portable and disposable. An opportunity to draw anything, document and develop any idea quickly, without fear of critique, it enables a freedom of expression.

At the end of the week you can review the concepts, ideas and sketches in your sketchbook. If they still seem like they have merit, expand upon them, produce rivalling solutions and use heuristic techniques to find how far an idea can go.

In effect, I have just described how I was introduced to low-fidelity prototyping.

The Modern Sketchbook

We are very lucky these days in that we don't even need to carry a sketchbook and pens with us anymore. My smart phone allows me to take photos, sketch ideas and even draft this blog post.

You are Responsible for Your Development

Recognise your Opportunities

When I realised that we had an issue at work regarding application user interfaces, I saw an opportunity. The company was keen on me learning about UX and how we could adapt to create solutions geared towards the customer, they didn't, however, want any time devoted to this during working hours.

This is not necessarily a stalemate; I want the skills, and the company wants to have these skills in-house, but they are not in a position to help me acquire these skills. The answer, go get the skills!! These new skills will open up opportunities for you to work on a wider range of projects, and as a bonus you'll get that lovely post learning bliss once your course or home project has been completed.

It Always Works

There are two scenarios that can come from this, and believe it or not, they are both positive.

1. You help your company excel through your excellence - Everyone's happy.
2. The company decide that it isn't interested in the new skills that you have acquired - It's possible that either you missread the signs, and they don't actually want those skills in house, or that the company is a bit self centred.

If it's the later, it doesn't matter, you haven't wasted your time. You have a new skill. By understanding the relationship that you have with your company, you can focus on what is right for you to be the best that you can be. Ultimately it is up to you to make this happen.

Our day-to-day job will throw up these opportunities all the time, all we need to do is pick one, gauge interest from our employer (they may wish to invest time or resource), learn something and produce something. I would always suggest that reading a book or attending a course is fine, but you should produce something to prove to your self that you have made tangible progress.

Make Tasks Visible

As discussed previously, we have used VisualWIP on projects to enable the whole team to see a task board showing the current state of our features for delivery. This application pulls from our data in TFS and the layout can be configured via an XML file (supported by a visual design mode within the application).

What if...

This application has worked well for us, but what if there is a reason that stakeholders can't run this 3rd Party Software. Perhaps it's against IT policy, maybe it feels too foreign for some of the team to comfortably use. Well, as long as we have a browser we can access this data without the need for Visual WIP or even Visual Studio.

By entering the TFS Url (inc. port) into our browser, we can run reports on the data as easily as if we were in the Visual Studio's Team Explorer. We can view and edit tasks (dependent on our TFS project permissions) and view any reports that we have created against the repository data.

Later versions of TFS enable you to access the contained data with relative ease via the web portal. Allowing an immediately accessible dashboard from which you can view the task summary, burn-down data and user defined queries. We also directly manage the backlog and sprint tickets thanks to the inclusion of an interactive task board.

I manage my own personal development tasks using the Team Foundation Services exposed through the visualstudio.com portal.

 

Keep it Visible

There should never be a reason for the teams tasks to be obscured. The whole team should know (and be able to see the context of) what they are doing. Maintaining the transparency of tasks that produce feature completion enables the team to work efficiently and allows the outstanding effort (scale of work involved) to be measured and managed effectively.

Versioning for a reason

Please do not push an un-versioned release to your test environment only to recompile and push a versioned dll to your Production environment. If the version numbers do not match then you should not presume that the application code will behave in the same way. If your QA and Testers have signed off version 0.0.0.0 of the application (which could be absolutely anything) How can your product manager confidently allow version 1.0.0.0 or 1.3.11.2 to be released.

So we know that version numbers important, but for whom?

Software version numbers are there for the management of the software through all of the processes that follow the code being written. We need to know what code is being tested, we need to know what code the user has signed off, and we need to know what features are being delivered to the end user. The only person that doesn't need to know about the version number is the user themselves.

How do we keep our version number unique?

The version number of a .Net assembly is made up of 4 sets of numbers (Primary, Secondary, Tertiary and Quaternary). We *could* just use four sets of random numbers, alternatively we could make this version number into something more meaningful.


We could use the Primary number to represent the primary functionality offered by the product. When there is a significant upgrade to the functionality, perhaps the number could increment based in the completion of an epic story. Given this, the product manager is able to understand what his product is offering based on this number.

We could use the Secondary number to represent incremental updates to the existing functionality. These would be enhancements to existing functions of the system, perhaps indicating project milestones or story completion.

We could use the Tertiary and Quaternary numbers as an incrementing 'unique' aspect to the full version number. I have previously used these to signify the time from the start of a Product's development. Currently I am using the Tertiary number to represent the days since development began and the Quaternary number to state the build number for that given day.

What have we got?

We've now got a version number that is not just unique, and therefore traceable through all stages of our development and deployment processes. But one that also contains meaning for everyone involved in the process of delivering the software to the end user.

Festival of the Spoken Nerd

Last year I went to the theatre to see Festival of the Spoken Nerd. It was a really fun show, full of tweeting, geekery, Science, Music and Jokes. If you get the chance, try and watch one of their shows, they will be trying out new material in February and March.

Spoiler Alert

Last years 'Full Frontal Nerdity' tour described The Mould Effect by Steve Mould

There was also smoke ring William Tell moments and a nice talk about RGB.

Inspired by this, here is an RGB excel image of my project team. 

My Team. Zoom in for the RGB values,  and out for the low resolution image to appear.

The Utility Belt

Every month I give a presentation to my company's development team. For Decembers presentation, I asked for the group to have a think about the tools and utilities that make their (development) life easier. I gave each developer up to 5 minutes (per tool) to present to the team, focussing on "what is it, where is it, why they have found it useful".

This session was aimed to help increase awareness of some of their great finds and to encourage their adoption. I presented two tools (orca and wilogutl) from the Windows Installer SDK and a one page stocking filler. The presentation went really well, achieved its objectives and received some great feedback. A nice by-product of this session was that it helps build confidence across the entire group.

Extract From Presentation

As long as your company policy and the product licence allows it. Please share your love of the utilities that make your life easier with your co-workers. If they are good for us, they may be good for them too and ultimately make your department more productive.

Remember, Batman doesn't need super powers, but he does rely on some great tools in his utility belt.