Tag: software development

Speaking Event – The Science of Diversity

Myself and two of my colleagues will be talking about the science of diversity and whether diverse teams are better than non diverse teams….
If you are in London please come along! http://www.thoughtworks.com/events/science-diversity
——————————————————
ThoughtWorks would like to invite you to meet with us at an upcoming event. Please share!
 
ThoughtWorks deliver software to people with ambitious missions and we’re looking for talented techies to join us. We value diversity and on 18th November we are hosting an evening with our CTO Rebecca Parsons who will be taking a scientific and technical approach to answer the question ‘are diverse teams better?’ 
 
There will also be an opportunity to network and find out about careers with ThoughtWorks. 
You can register here – we look forward to meeting you!
Please contact Katie kpartridge@thoughtworks.com @katielisa52 for more details.Inline images 1

Creating C# .Net Websites in IIS with a Powershell Script

I created this little script to automate the creation of websites in IIS. It’s written in powershell.

You will need to run this script in powershell thats running in Administrator Mode.

Prerequisites:
You will need to have .net installed.

Step 1 Loading the Web Administration Module

This script is using the WebAdministration module to do the creation and removal of websites. To be able to load this module before it runs my powershell script I create a .cmd file that I would call that would load this module and then call my main powershell script.

install_website.cmd

powershell -executionpolicy remoteSigned -command import-module .\PSCommon\WebAdministration;.\install_website.ps1

Step 2 Creating the main .ps1 script

Create a new script, I called mine install_website.ps1. I put mine next to my install_website.cmd.

install_website.ps1

C:\Windows\Microsoft.NET\Framework\v4.0.30319\aspnet_regiis.exe -i

$website_name = "MyWebsite"
$website_source_directory = resolve-path "..\MyWebsite"
$website_virtual_directory = "IIS:\Sites\MyWebsite"

$app_pool_name = "MyWebsite_AppPool"
$app_pool_virtual_directory = "IIS:\AppPools\MyWebsite_AppPool"

$sub_application_name = "SubApplication"
$sub_application_source_directory = resolve-path "..\MyWebsite.SubApplication"

Function CreateWebsite {
 New-WebAppPool $app_pool_name
 Set-ItemProperty $app_pool_virtual_directory managedRuntimeVersion v4.0
 New-Website -Name "$website_name" -PhysicalPath $website_source_directory -ApplicationPool "$app_pool_name" -Port 8082 -Force
 New-WebApplication -Name "$sub_application_name" -Site "$website_name" -PhysicalPath $sub_application_source_directory -ApplicationPool $app_pool_name
}

Function RemoveWebsite($app_pool_virtual_directory, $site_virtual_directory, $website_name){
 if (Test-Path $app_pool_virtual_directory){
   $webSite = Get-Item $site_virtual_directory
 if ((Get-WebsiteState -Name "$website_name").Value -ne "Stopped") {
   $webSite.Stop()
 }
 $poolName = $webSite.applicationPool
 $pool = Get-Item "IIS:\AppPools\$poolName"
 if ((Get-WebAppPoolState -Name $poolName).Value -ne "Stopped") {
   $pool.Stop()
 }
 Remove-Website -Name "$website_name"
 Remove-WebAppPool -Name $poolName
 }
}

RemoveWebsite $app_pool_virtual_directory $website_virtual_directory $website_name
CreateWebsite

As you can see I have two functions. One creates my website and associated app pool, the other removes it if it already exists. So I can run my script multiple times without a problem.

CreateWebsite, first sets up a new app pool, sets its ManagedRuntimeVersion to v4.0, creates a new website and then we also needed a sub application below that, so also sets that up.

The fear of blogging about technical topics…

I rarely blog about technical topics, despite my main trade of being a developer. The prospect has always scared me, and from others that I’ve talked to I’m not the only one.

The irrational thoughts that tend to go through my head are:

  • What right to I have to blog about technical stuff?!
  • Major case of Imposter Syndrome
  • What do I know that the internet doesn’t already?!
  • Will people judge me about what knowledge I do have?
  • What if  I’m wrong?!

Wonder if anyone else finds this too?

Well, we have to embrace whats scary to grow. So I have set myself a target of at least one technical blog a month.

These are my mantras to help me feel more confident about it

  • We are all always learning. There will always be people that know more about something than you, but there will always be people who know less. Things that I find useful when I am learning WILL be useful for other people who are learning.
  • If I had to hunt about on the internet for half an hour to find out how to do something,  if I can give an example that might save someone  haf an hour of googling, then I have made a tiny difference.
  • I must embrace feedback! If people leave comments, and share other ways that I could do things better, I should embrace and learn from these.
  • I am not ever pretending to know everything… these are just things that have helped me and I hope they might help others.
  • I can put things down here, so I can remember them for next time.

Here goes!

I’d love to hear any thoughts if you feel the same about technical blogging, or even better if you used to, and how you got over it.

Gender Diversity on Teams – Roundup

Wanted to keep a note of a bunch of articles and books that I found recently around studies about gender diversity on teams. Prompted by a discussion with a programme manager at an investment bank and then subsequently with my fellow ThoughtWorks colleague Nic Ferrier

I found these often quoted “facts” and was trying to hunt down their sources…..

National Center for Women in Technology – Resources
The Impact of Gender Diversity on the Performance of Business Teams 
Gender Diversity and the Impact on Corporate Performance – Credit Suisse Research Institute
Gender Diversity, Team Decision Quality, Time on Task, and Interpersonal Cohesion
LBS study shows addition of women to teams improves performance

Reflections on my last gig…

I have just rolled off of my project of the last 8/9 months, and thought it was a good point to reflect on my time there.

Once again I had an awesome time. I learnt a lot, met some great people, made some good friends, watched people grow, and most importantly contributed to a great product. There were a lot of highlights, too many to name them all, but here are 5 I picked out.

Non-hostile atmosphere.

The whole team was respectful of each others ideas and skills, open to change and new ideas and a lot of fun. One of the first projects where change has not been outright resisted and refused. As consultants I can see that it’s natural that our presence on a team can cause hostility, but we’re here to help, honest! This lead to a much more productive and more pleasant working environment, allowing people to try new things and bring their ideas to the table.

From the moment that I got there I felt like there was space for my ideas and people were ready to listen to them and give them a go. Wonderful feeling.

It sounds like a small thing but its really not. When a team is willing to change the way it thinks and embrace new ideas, everyone can contribute to that success, it’s not just the persistent, rebellious people (which is often the role that ThoughtWorkers have to take) who can make change happen but there is space and support for everyone to have ideas and change the way things happen.

Feature Leading. Our tech lead was comfortable letting some of us lead a few of the features, which was great. I got to look after the online sales feature we added and an emailing piece. It wasn’t so much as an official thing but more an organic thing. As well as being involved in writing the code, I helped with analysis, spent a lot of time talking to the teams that we were integrating with, kept an eye on and helped out with testing and deployment and generally provided a consistent technical vision for the whole feature. It’s great experience for people who are moving towards becoming a tech lead, without the pressure and responsibility for being the actual tech lead. I found it really energising to have such focus on one feature.

Coaching / Mentoring.

I went to a leadership academy event recently where one of the speakers said that you are not a great leader unless you have pulled people up with you. That has really stuck with me. What kind of leader can you claim to be, if you haven’t helped other people learn and grow?

The client had a female developer on their team who had never met another female developer before she met me. She is also very talented and passionate about technology with some great potential. I spent a lot of time with her coaching and mentoring, and this relationship will outlast the client engagement. I get a massive amount of satisfaction helping others reach their goals and look at the world in different ways. Also being able to provide the support that people need to grow.

I also tried quite hard to make sure that I was giving “in place feedback” i.e. immediate feedback in a situation, mostly whilst pairing etc. One of the other TW Developers on the team commented that he heard me doing this often and learnt a lot from just listening. Need to do this more though. Especially when there are more “heated” pairing situations.

A positive attitude can go a long way.

Generally I’m a pretty positive person, and I got a lot of feedback about how this changed the whole atmosphere of the team. It only takes one consistently negative person on the team to start bringing the entire mood down. Remember this and try and look at situations positively and with energy.

There is more to being a developer than just writing code for the story you’ve been given.

As a developer, you are responsible for getting features that help the people using them into the hands of the people using them. It is your job to push back if you think requirements don’t make sense. It is your job to ensure that the software you are producing is of a good quality. You should not just be coding whatever you are told to without questioning anything. So as well as writing code, be part of the requirements definition, the testing, the conversations with stakeholders, with the people that are deploying your code if it isn’t you. Software that is not in the hands of the users and being used is useless.

As well as advocating the above, I spent some of my time on the team championing and facilitating the retrospectives, launching lunch and learns, being part of the inception, and countless other things that weren’t strictly in the remit of a typical “developer”. For me this is normal as they are things that I enjoy, but I don’t think this was the kind of developer that many of the client devs had met before! I hope that it has influenced them a bit.

Technical highlights

No-SQL datastores (Dynamo DB)

JavaScript testing (Jasmine)

JavaScript frameworks (KnockoutJS)

E-Commerce

In process browser testing (Plasma)

Feature driven development (Starting with high level feature tests and build down)

Analysis of logs (Stash)

Releases every week with blue/green deployments

Our tech stack:

Written in:

C# .Net, Javascript (KnockoutJS, JQuery), Razor, MVC4

Dependancy Injected with:

Unity

Package Managed by:

NuGet

Tested with:

Moq, Plasma, Selenium Webdriver, NUnit, JMeter

Data Stored in:

SQL Server 2012, Dynamo DB

Deployed on:

Amazon EC2, IIS,

ORM Layer:

Linq to SQL, Dapper

Deployed and Built using:

DBDeploy, MSBuild, Team City

Monitored with:

Stash

Coded using:

Resharper, Visual Studio 2012

…..and probably others that I can’t remember off the top of my head.

Bringing visibility to code quality metrics

It’s often hard to measure whether or not the quality of your codebase is improving. It’s also very easy to become overwhelmed by software quality metrics. With so many, you stop paying any attention.

One of the metrics my current team has been paying a lot of attention to is a “duplicate count”. It’s a measure of how many lines of duplicated code you have in your codebase, both in the test code and in the production code. Team City, which we are using as our Continuous Integration server, has a built in duplicate count, so that every time you check in you can see whether it has gone up or down. (The way that it counts is sometimes a bit strange… but I won’t focus on that!) You can make sure that the build fails if it goes over a certain number.

We were trying to focus on “improving the quality of our test code”, especially our high counts of duplicates within our test code. As this one was easy to measure, we thought we’d focus our efforts on a single metric and consciously reduce the number with each check-in.

Feeling particularly arty that day, I decided to create a physical counter that we could use to measure how we were doing. I created one counter that I put in front of the build monitor. Leaving the numbers to be coloured in as people got to them. This would then be flipped over as people reduced the numbers.

I also created a summary of the numbers to put on the story wall, so that at standup we could always check on progress. Noting what the number was at the start of the week and then what the number of duplicates was for that particular day.

It worked amazingly well. Suddenly this group of grown men were enthusiastically running over to the build monitor to change the counter as they reduced the duplicates. Cheers would go up when a pair checked in code that reduced the number. Turns out “gamification” is a real motivator. Before I knew it, people were getting shout-outs at standup for being particularly good duplicate reducers that week.

Having the additional counter on the main story wall meant that people outside the developers were aware that we were paying attention to the quality of our code and actively trying to improve it. It has now become part of our daily standup routine to talk about it.

The counter worked so well, that we then introduced one for the number of warnings in the code base. Pick a quality metric and try it!

IMG_1455IMG_1454

Git for Beginners – A Sample Workflow

So here is my *very* happy path sample workflow, using local branches, with explanations for first time users of Git. See here for a worksheet with useful git commands and their uses and a sample workflow. This covers only what this post covers.

You will aslo see references here to “git tf”. This is not an alias but a cross-platform, command line tools that facilitate sharing of changes between TFS and Git. The commands are the same as the regular Git ones. But slightly different for pushing and pulling. See here for more information.

A familiar workflow:

  • Get the latest code
  • Create somewhere to put the changes you are about to make
  • Make changes
  • Make sure you are happy with them and want to integrate them back into the main repo.
  • Check for any more updates
  • Push your code into the remote repo

Now broken down into the Git steps to achieve the above.

1. Get the latest code

Make sure you are on master. Use git status to check.

Pull down the latest changes onto master git pull

2. Create a new branch for your story work.
Name it after your story so you can remember it later. git checkout -b [branchname]

If you do a git status now you will see you are on your new branch.

3. This is where you code as normal, running your tests etc.

4.Commit your changes to your branch.
When you are a point where you are happy with your changes and you want to pull in everyone else’s changes… You can commit as many times as you like to one branch but try to keep them small and in a working state.

A git status will show you your changes.

You will see the files that git is tracking and has staged and those that it has not. git add . Or git add -A will add any untracked files.

Next commit your files to your branch. git commit -am "[message]"

When you do a git status now, you should see no changes.

If you do a git log you will see that your commit is now part of the branches history.

5. Get latest code on master

Move back onto your master branch git checkout master

If you do a git log at this point, you will notice that your commit is not yet on master, and the latest commit will be from when you last pulled.

git pull will bring down any more changes.

6. Update your branch with lastet code

Move back to your story branch git checkout storyname

Next you are going to rebase your branch. When you originally created your branch it was based on point in time x, since there have been additional changes (time y), you want to tell your branch that you actually want it to be based from time y and you want your changes on top of that. So now git rebase master will update your branch with all the changes that are now in your master branch. As you watch the output you will see that git pulls out your change, fast forwards to time y and then replays your change on the top. Now you may have conflicts at this point if two people have changed the same thing but will assume things are all good.

Now run your tests and make sure everything is good.

7. Get your changes back into the main repo.

Move back to your master branch git checkout master

Merge your branch back into master with git merge storybranch

git push will then send up changes to the remote repository.

Next time… Merge conflicts…..

Becoming a Tech Lead

I’ve been a senior developer for over a year now and I’m starting to think about how I can grow into an awesome tech lead.

I’ve always wished that there was some kind of manual that would explain to me how to become a tech lead. Which skills I would need to learn and grow, how to know what to worry about and what not. What kind of things I should be looking out for on my team and how to lead a group of developers to make good quality software.

Alas it seems that there is no such manual and you really just have to get out there and try and learn quickly.

A couple of months ago I was fortunate (or unfortunate depending on how you look at it) enough to “try out” being a tech lead while the other senior developers and tech lead all went on holiday for 2 weeks at the same time, leaving me to try to hold everything together while they were gone.

Initially I was quite daunted, but hey you don’t get the opportunity to ‘play’ at being the tech lead without having to actually BE the tech lead very often. I was also very lucky that I was in such a ‘safe’ environment and could fail fast and learn quickly.

These are some lessons that I took away from that week:

  • Trying to stay in the pairing rotation and being a useful part of the pair while starting out in this role is really hard. I started this way at the beginning of the week, but found it too distracting for both me and my pair when I kept getting pulled away for other discussions. The constant context switching every 5 minutes meant that I could never concentrate fully on pairing effectively. Once I took myself out of the pairing rotation and worked on my own, my stress levels and concentration were much better, and I didn’t feel guilty about being an awful pair. It also meant I was free to float around and help anyone else where needed without worrying that I’d left my pair in the lurch.
  • I kept a list of all the things that I saw going on around me that I thought might be ‘smells’. There were a few things that I simply didn’t have time to worry about, making a note of these and moving on made it much easier to not get overwhelmed. I would then come back to the list often to see what I could tackle next or note down anything that was changing. This was very helpful when it came back to handing the reins back over so that they could see what had been happening and any solutions that I had to problems that I hadn’t had time to dedicate too.
  • Don’t let anyone see your fear! There was a certain amount of ‘fake it until you make it’. Present a confident front. Admit it when you don’t know the answer to something and go and find out the answer. But letting on that you’re nervous or that you’re not sure what you’re doing is not going to make anyone want to follow you. I was very lucky that the rest of the team were supporting me and understanding that someone  had to play this role.
  • Trust people. Theres no point hovering over people and/or  micromanaging people. Let them get on with their work and they’ll come to you to ask for input on their own.

Since then I have been “feature leading” one of the main streams of work for our current release which has been really fun. Especially with the ‘real’ tech lead back. Thats another great way of getting experience in leading a technical team. Take charge of a stream of work and become the point person for it. It’ll give you great exposure to teams outside of your own. and let you see the consequences of design decisions that you made earlier on.

See my colleague Pat Kua’s post on Feature Leading here. If anyone has any resources on growing into a technical leader please share!

Bringing Visibility to Retrospective Action Items

I’m a big fan of the Retrospective. I think it’s so important to take time to look back and reflect on how things have been going, and think about how to make things better on your team. There are heaps of different kinds of retrospectives for different occasions and to enable you look at your from lots of different angles.

Regular retrospectives will open up great communication between team members and make it easier to talk about issues and successes.

However, you can’t reap the full benefits of retrospectives if nothing changes afterwards. If the team feels like they are losing an hour of their lives to retrospect and then nothing happens they aren’t going to be keen to have one again.

Some things that I think are important:

  • Retrospectives should happen regularly. Every 1-2 weeks AT LEAST.  More than that and the feedback cycle is too long, the retrospective will likely take hours because so much stuff has built up.
  • Keep them energetic, change up the format often and get different team members to facilitate and take ownership.
  • Keep them constructive, follow the prime directive and ensure that there are action items that have owners and are achievable.

I recently joined a team that was feeling quite disillusioned with their retrospectives. They were every 3-4 weeks, and the same issues came up time and time again. Nothing was changing and the team was frustrated. On my second day on the team we had a session and everyone was grumbling before we had even started, that it was pointless. It broke my heart.

I felt like there was a massive lack of visibility to the items that had come up, no ownership and no follow-up.

So I got hold of the items that had come up and created a Retrospectives Action Items board that lists all of the action items, their owners and equally as importantly, which ones we have actually achieved so that the team can see that we are making headway.

This board lives next to the story wall where we hold standup so that we can talk about the items every few days, see progress (or lack there of) and provide a friendly reminder. (My crafting skills pale in insignificance compared to some of my past team mates, so sorry about that!)

  • Ensure the whole team can see the action items and who’s responsible for making each one happen.
  • Regularly bring action items up and check progress during standup, remove any blockers if necessary.
  • Celebrate the items that do get done.

So far this has worked pretty well. I already feel there is a better energy and things are changing as a result of our last retrospective. Next mission, get them to happen much more often!