Design, Code, Release

So 2013 begins….

2013-01-18T08:30:00.000Z

This post has been primarily delayed due to illness but also being very busy my new job.

Just like previous years I’m treating this as a retrospective on the previous year and planning for the year to come.

2012 goals

At the beginning of 2012 I set out the following headline goals I wanted to achieve:

Blog posts
Read books
Presentations
MVP
Coding

What did I achieve?

Blog posts

Well in 2011 I published 30 posts but in 2012 I only managed 19 posts which is a little disappointing, but interestingly the traffic to the blog increased by over 2000 visits so hopefully I’m doing something right.

My most popular post of the year was Is software craftsmanship a luxury most can’t afford? with 476 views.

Read books

I had a very long list of books that I wanted to read but I only managed to read 6 and post a review of 2 of those. My hope is to try and post reviews of the other books I read during last year and any books I read this year.

Presentations

Although I’ve come up with some ideas I ended up only created 1 new presentation this year “Inversion of Control containers Vs hand rolled - how they compare” which I got to present at DDD10.

MVP

At the beginning of the year I spent some time looking into the MVP program, there was the post by Rob Eisenberg about why he turned down an MVP and then other posts about how good it was to be one and posts such as Brent Ozars’s about what being an MVP meant.

So I now have a fairly good idea about what the MVP program is about and a better understanding of how you could be awarded an MVP. For now I think its safe to say I won’t be getting an MVP any time soon so am going to park this goal.

Coding

Last year I split my coding goals in to “will do” and “nice to do”

Will Do

Concerted effort to finish the OSS project I started about 2 years ago

Complete failure on this, I never managed to even open the project the entire year. I haven’t given up on this and am

Improve my JavaScript

I did manage to do a little bit of JavaScript but not to the level that I had envisaged and unfortunately for me in the last year the number of JavaScript frameworks seems to have exploded so there’s so much more I need to learn.

Continue working on my ADO.NET DAL

I never managed to large changes I wanted to make but did manage some minor changes to the internals for people that wanted to use it in an actual product.

Nice to do

NuGet

Although I didn’t publish a package publically I did in work, configuring TeamCity as a local NuGet server to be used through out the team which was almost effortless to set up and very easy to use.

Learn PowerShell & Learn Python

I never managed to get to either of these items although its still on my ‘wish list’

Develop WP7 apps

I attended a WP7 phone camp in January and I did create a WP7 app, Math Power a maths based game, which to date has been downloaded 1342 times which I’m very happy with.

What else?

Jobs

During last year I ended up changing jobs twice having 3 different jobs over the course of the year. This wasn’t planned at all and has ultimately lead me to being a contractor so I’m sure that work wise 2013 is going to be interesting.

Community

During the year I was lucky enough to be selected to present at both DDD Southwest 4, DDD 10 and DDD North 2 as well as at NxtGen Southampton and Dot Net Developers Network. As always I really enjoy doing these presentations and value any feedback I can get about how they went.

I have also been involved in some development work for a user group which I hope may get to see the light of day during 2013.

Continuous Delivery

If I’m totally honest I’m really chuffed at managing to set up a continuous delivery pipeline at one of my jobs this year which meant code was pulled from DVCS, built, tested and deployed to a test environment. What makes this different from what I’ve done previously is that it also included database deployment as well and I aim to blog about the technology used in the not too distant future.

This year…

In the same vein as the immortal words of “Stars in their eyes”…this year Matthew I’m going to be looking to:

Make better use of personal time

Looking back over what I’ve done last year I can see that in my spare time I tend to focus on just one thing which is why when I’m doing my own development I don’t write blog posts, read books or watch training video’s. So this year to try and get more done I know I’m going to have balance out what I do which may mean that it takes longer to finish things off but at the same time I hope to keep things moving and not appear to “go dark”.

Learn JavaScript

I’m making this one of my primary goals for the year, JavaScript is here to stay and anybody involved in web development will need to know all about it, main stream libraries e.g. jQuery and related technology i.e. TypeScript, CoffeeScript, etc. I have already watched a Pluralsight course on knockout.js and plan to watch more along with a selection of books to read.

Investigate Software Craftsmanship

I am going to continue my investigation of software craftsmanship by working through the further reading list and to continue blogging my thoughts about it.

As part of this I may attempt to set up a local craftsmanship group to be able to try and meet up with other people for discussion and writing code. My main impediment for this is a venue so if I manage to remove that I will be looking to pursue this further.

Code

After 2 years of inactivity I need to either push on with my OSS project or ditch it since if its not out there solving a problem its just waste.

Again I have ideas around my ADO.Net DAL that I want to pursue and if I can find time I may look at doing so.

Summary

Compared to last year I have massively reduced my goals having only 4 goals, I’ve decided that reading books, writing blog posts and writing presentations are things that I’m just going to do and as such I’ve removed them as goals.

As always if a user group would like me to do a presentation give me a yell and lets see what we can arrange.

I’m hoping my more focused goals will allow me to make progress with them and be able to achieve more than I did last year.

So that’s what I’m doing, what are you planning on doing in 2013? what are your goals?

Build errors with TeamCity, MSBuild, MVC Build Views and .Net 4.5

2012-10-23T08:30:00.000+01:00

Recently I moved an application from .Net 4.0 & MVC3 to .Net 4.5 & MVC4 which for the most part went fairly painlessly.

Previous to the .Net 4.5 upgrade the code was already being built and tested on TeamCity, but as part of the upgrade exercise it was decided to implement deployment from TeamCity using web deploy to a test server.

Getting web deploy set up on TeamCity is fairly painless and Troy Hunt has a nice set of posts about this, what it generally boils down to is using MSBuild to package the code and then calling web deploy to use the newly created package.

I set up the necessary build steps only to find that I was getting build failures on TeamCity when using the MSBuild runner (previously had used VS Solution runner) with the following error:

ASPNETCOMPILER error ASPRUNTIME: Could not load file or assembly 'System.Web.Razor, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35' or one of its dependencies. The system cannot find the file specified.
Project XYZ\XYZ.csproj failed.
Project XYZ.Tests\XYZ.Tests.csproj failed. Project ABC.sln failed.

I appeared to be able to solve this by adding an additional MSBuild property /p:VisualStudioVersion=11.0 which I found from this stack overflow answer.

Once done the code then built successfully but when it then attempted to package and deploy the web site it was failing with the error:

MvcBuildViews AspNetCompiler
AspNetCompiler C:\TeamCity\buildAgent\work\f2cfe4b9b1db787a\XYZ\obj\uat\csautoparameterize\original\web.config(27, 0): error ASPCONFIG: It is an error to use a section registered as allowDefinition='MachineToApplication' beyond application level. This error can be caused by a virtual directory not being configured as an application in IIS.

I quickly discovered that this was an issue with the package command and happened because the obj folder wasn’t deleted, normally you get around this by altering the project file and telling it to use a different folder to output files to but this didn’t work for me.

After much searching I finally found the answer with this comment on a Phil Haack's blog post where I needed to add another MSBuild parameter /p:BaseIntermediateOutputPath=<your path here> which then allowed the TeamCity agent to create the package and successfully execute web deploy.

This took me a couple of days to resolve and the initial problem was that I had just upgraded to TeamCity 7.1 and incorrectly suspected it of causing me the problem, I was wrong.

Hopefully this post will help you if you too run into the problem.

Why does agile fail?

2012-10-18T08:30:00.000+01:00

There is more than one company out there that has tried to “go agile” but have ultimately failed and gone away with the impression that “agile just doesn’t work” or “agile’s great but just not for us”. You also have the situation where you have a company that has been working in an agile manner and then agile breaks down.

So why do people fail to successfully implement agile practices? what are the common reasons that are cited? who is to blame? In this post I’m going to cover some of the factors I’ve seen that can cause an agile adoption to fail, I’m not going to offer any suggestions on how to combat the various reasons but you could consider this a list of symptoms that could indicate problems if you want to implement agile in your organisation.

Reasons for failure

Culture – organisation sees no need to change
Control – management want to control what people do
Wrong focus - focusing on perceived value of a project plan
Buy in – people implementing don’t care about the process not invested in what they are doing
Pseudo experts – people who “believe” they know all about agile when they have limited knowledge
Clients – fixed term contracts, non-agile customers, square peg round hole

Culture

What makes up the culture of a company? The culture comes from the people who work there, their attitudes towards the work, the processes that they follow day to day and the work that they do; their behaviour at work is driven by what they achieve and how they are treated dependent upon whether they succeed or fail with the tasks they undertake.

An organisation will tend to hire and retain people that want/like to work the way the organisation works this in turn reinforces the culture which has the side effect of making change even more difficult to introduce.

Culture is, IMHO, the biggest cause of failure of agile adoptions, if you are working in an organisation that has a closed mind-set that does not easily accept change or attempt new things you will struggle to get any traction for the agile practices you want to implement even if these practices could very well help the organisation grow and succeed.

In this situation is very unlikely that anything you can do will actually make a difference and nothing short of an epiphany from the higher managers or a company crisis will make the organisation consider the “radical” approaches outlined in agile practices.

Control

In a waterfall based project control usually sits with a manager and/or a project manager which leads to developers being told what task they will work on and sometimes even how long they have to complete it.

When trying to adopt agile this type of control is a direct opposite to practices you want to start using where the developers work out what they can achieve and it is this tension between developer and manager that can cause even existing agile practices to fail. A developer knows that within the organisation authority sits with the manager and if the manager starts telling them what to work on unless their is a person, or people, able to tell that manager to stop then agile practices can very quickly breakdown.

The role of a Programme/Project manager is a strange dichotomy in that although they usually don’t have any authority over individuals they have ultimate responsibility for successful delivery of a project. This can lead to a desire to actually control what happens on a project which in turn can lead to issues as they try to assert control over what the team does and tell them when they should deliver, again going against agile principles & practices.

Wrong focus

If the organisation is operating in a waterfall manner it believes it can predict the future and can therefore determine every aspect of a project before it begins. This leads to the expectation that any estimates given by the people involved in a project will be hit, effectively making them commitments not estimates, and so create project plans showing milestones and completion dates based on these “estimates”.

This type of organisation tends to focus on the wrong thing as it is more concerned with the project plan, or cost of the project, rather than any perceived value of what is being produced; often it is only at the end of the project when the software is complete that the actual value of that software is considered.

This is the antithesis of agile where it should be about delivery of value to the customer rather than following a plan for the sake of it, striving to ensure that the organisation is, wherever possible, deriving value for the organisation as the project progresses rather than just at the end.

Buy in

Agile is a collaborative effort, you need the developers, managers, PO’s, etc all wanting to work together looking to deliver value to the business, but to achieve this people need to have “brought in” to the concepts and principles behind agile.

If you don’t have this buy in from all the various people involved then your agile implementation may be ultimately doomed to failure. It may well work for 6 months or a year but all it takes is for one or two of the people involved who are passionate about agile to move on and the rot starts and before long the practices are either just being followed cargo cult style with the people who are left not knowing why they are doing something, or they are dropped completely.

Pseudo Experts

A pseudo expert is a person that has worked in a an agile environment before, has attended a talk or read a book on agile, they usually haven’t been deeply involved in all aspects of agile (if any at all) rather they believe they have a deep understanding allowing them to direct others in adoption of agile principle & practices.

However, their limited knowledge of the principles & practices can lead to problems when faced with the normal day-to-day challenges an agile team faces as when the pseudo expert doesn’t have a solution to a problem then at best the “expert” consults their books on what to do or at worst makes it up.

Frequently with the pseudo experts if they have had some success with their agile implementation they develop a closed mind believing that they know all about agile which leads to an inability to change producing a further barrier to being able to actually adopt agile.

Clients

When developing software both internal and external clients usually want to know exactly what they are getting and when they are going to be getting it, it is the classic iron triangle.

For external clients this is a little more understandable as they are paying money to a 3rd party to create software for them; historically in a waterfall project external clients have had very little direct involvement apart from at certain “milestones” so seek to assert more control over the project through the contract which can lead to focusing on the plan rather than the value (wrong focus). There are very few companies which happily transition from purchasing software with a set deliverable to a situation in which they believe that they may not get all the features/functionality that they want.

Internal clients should be easier to convince that agile will deliver more value for them but if they have to get budget approval for the work to be done then you will often find an internal client acting like an external client and wanting guarantees over what they will have delivered. Whilst frustrating this is more a symptom of a dysfunctional organisation which places more emphasis on cost than value, again the wrong focus, than the actual internal clients.

Summary

These are some of the most common symptoms that I’ve come across and you may see one or more of these in your organisation, if you are unlucky you may see all of them, it doesn’t mean you that your organisation can’t become agile but you need to be prepared to face and overcome these challenges.

Stop using Priority 1!

2012-10-09T09:50:00.001+01:00

I will come as no surprise to hear that I read a lot of blogs about agile and agile methodologies and when it comes to ordering/prioritising the backlog you will usually have people talking about priorty 1 this, priority 1 that and with the stories being numbered in sequence e.g. 1,2,3,4, etc

To be honest I'm surprised that after all the years agile has been around that this is still what people are suggesting you do since its actually a complete pain to work with.

What am I talking about? Well if you have a backlog of say 30 items (I'm assuming they are in some sort of electronic system) and they are all number sequentially then if the business suddenly discovers something that must be "Priority 1" you have to alter every other story in the backlog to adjust their priorities and the work required to do this is really pure waste.

A better way of handling the priority is to invert the numbers, make the highest number the highest priority, this way if you want an new highest priority item you simply find the current top priority and add to its number, no need to reorganize the backlog, no change to what you have no waste, plus people often like the idea of giving a big number of a top priority so you are likely to get little resistance there.

An added bonus is with more numbers to "play with" you are less likely to get product owners/stakeholders trying to make everything "Priority 1" and more likely to engage in ordering the stories appropriately for the team to work on.

Also to make your life even easier don't number your stories using sequential numbers leave space between the numbers so that you can slot new stories in between existing ones if you need to.

So instead of 1,2,3,4 try using 4000, 3000, 2000, 1000 it will relive you of a little pain in your backlog management.

DI != IoC

2012-09-06T08:30:00.000+01:00

At the weekend I gave the a presentation “Inversion of control containers Vs HandRolled” showing the difference between using an Inversion of Control (IoC) container versus doing the dependency injection yourself.

I was asked a question on twitter Tuesday

“@philpursglove: @nathangloyn meant to chat with you at #ddd10 about why DI != IoC. Have you got a blog on this?”

There was a brief exchange on twitter about this but I wanted to just put my thoughts down around this.

For me Dependency Injection is a pattern, it is where a class that uses other classes i.e. is dependent on the classes, has these dependencies injected into it, whether this injection is via the constructor, property or methods.

When people talk about IoC they most commonly think of a container such as Ninject/StructureMap/Autofac, they think about it as a mechanism to handle the injection of the dependencies so they don’t have to worry about writing all the code to do this.

I believe IoC isn’t just the mechanism to implement DI but its exact definition is a little more difficult to pin down, if you read this wiki on the Castle project documentation then IoC is all about frameworks if you read Martin Fowlers article then its a principle to bear in mind when building your application. One thing that Martin Fowler does say in his 2005 article:

“There is some confusion these days over the meaning of inversion of control due to the rise of IoC containers; some people confuse the general principle here with the specific styles of inversion of control (such as dependency injection) that these containers use.”

He is describing DI as a specific style of IoC but I believe it simpler to think of DI as a separate pattern that can stand by itself but could easily fall under the general principle of IoC, hence DI != IoC.

Interestingly the closer you look at IoC to me it seems very similar to the Dependency Inversion Principle but that’s another conversation

DDD10 Slides & code from the presentation

2012-09-04T20:56:00.001+01:00

On Saturday I presented “Inversion of control containers Vs HandRolled” at DDD 10, I had a really good time and wanted to thank everybody that came to the session, this post is to provide links to the slides and code.

The slides can be found here although the font seems to have been altered so it doesn’t appear as it did in the presentation, I didn’t create the slides in comic sans honest!

At the beginning of the talk I said I didn’t intend to upload the code but I was talking to Rory Becker at the geek dinner and he convinced me to upload the code so that others could look at/play with the code, so you can find the code here.

As always any questions feel free to ping me

Book Review: Continuous Integration in .Net

2012-08-01T08:30:00.000+01:00

Searching on Amazon for the phrase continuous integration (CI) you’ll get over 2000 results but looking at them you’ll find very few books actually on the subject.

This book has a unique slant in that it focus’ on the the .Net world and how you can introduce CI into your development practices and once implemented build upon that foundation to extend the functionality of your build server.

The authors have structured the book to take a CI novice from installing a CI server through to automating deployment or as Paul Stack describes in his talks how to climb the CI ladder.

Part 1: Getting started

In the first part of the book the authors introduce you to the concepts behind continuous integration explaining why you would want to introduce this practice.

Before getting to CI servers the authors spend a couple of chapters discussing the idea behind CI, the importance of source control in relation to the whole process and how you automate the build process using MS Build.

The next chapter goes on to talk about CI servers and introduces the 3 CI servers that are discussed throughout the book: Cruise Control.Net, Team City and Team Foundation Server. At each stage of CI described in the book the authors show how to implement the various techniques discussed in all 3 of the servers.

Next the importance of feedback that the CI server gives you is discussed, including the various forms of feedback - build notifications via email/RSS, external devices, etc.

The final chapter in this part introduces you to unit testing, firstly explaining what unit testing is and a brief introduction on how to do it before then talking about how you can integrate it into your build process.

Part 2: Extend it

The second part of the book is all about extending your build process.

This part has 2 chapters the first provides details on how to perform integration, system and acceptance testing by configuring the various CI servers to be able to utilise tools to run the various tests from NUnit for unit tests through to FitNesse for acceptance testing.

The second chapter of this part discusses analysing your codebase using FxCop and StyleCop to help you improve the code including storing reports generated by both tools to allow you to monitor how the codebase is improving over time and not deteriorating. There are also details on using NDepend (which I’ve blogged about before) which provides a report that you can store including a lot of key metrics that will show you where to focus any improvements you may wish to make.

Part 3: Smooth and polish it

The third part of the book is devoted to truly extend the functionality of the CI server beyond simply building and testing your code.

Generating documentation from xml comments using Sandcastle is the first chapter of this part enabling development documentation to be updated as part of the build process ensuring that they are always up to date.

Deployment and deliver of the applications are covered next showing you how add a visual studio deployment project and creating a Wix installer for windows based applications. If you are creating web applications details are provided on how to use MS Deploy to enable automatic deployment of the site upon successful build.

Database deployment is then covered, firstly the authors cover generation of SQL scripts through Sql Server Management Studio and how to run these from the command line but then going on to show how you can use RoundHousE to automate this as part of the process when you aren’t using TFS as your build server. For people using TFS the authors also cover Visual Studio Database projects as a way to be able to work with your database as well as deploying using this type of project.

The final chapter is all about your CI process and provides advice on dealing with slow builds, how to scale your CI and measuring the maturity of your CI process.

Summary

At the beginning of the book it clearly states that the book is intended for a reader that wants to “dive into” CI and that it is not really for experienced CI practitioners or build masters and I would have to agree with this, if you have been practicing CI and already have automated builds (or even better building and testing) it is only the last few chapters of the book that may contain anything new to you.

Also there are some oddities in the book, such as explaining how to use source control and what unit testing is and how to do it, which I think would have been better covered by being included as an appendix rather than an actual chapter. To my mind it would have been better to keep the main part of the book focussed on CI rather than attempt to give the reader a very brief introduction to the other subjects.

For a newcomer to CI in the .Net world I would recommend you read this book as it will provide you with information and guidance to help you get your CI process in place.

CodeProject

Feedback

2012-07-10T08:30:00.000+01:00

Everyday we need and use feedback to help us understand that what we are doing is working, when:

Executing a build - it tells us if the code compiles
All unit tests passing - tells us the code does what we expect
Acceptance tests passing - tells us the code is doing what the business expects

Day in and day out we utilise feedback in our work to help us write our code and improve what we are doing.

But what about ouside of code? do you utilise feedback to help you improve?

Do you:

Ask people to review your code?
Talk to your manager regularly about any targets you've been set?
Ask companies you interview with to provide feedback if unsuccessful in?
Ask your peers if there is anything you can do to improve?

What TDD has shown us is the tighter the feedback loop the quicker we can adjust our behavior and improve what we are doing.

Feedback may just be the most important mechanism there is to help you improve as receiving feedback, in whatever form, tells you about how you are doing. The feedback may not always be what you want to hear, it may even be painful, but if you want to improve listen to it as it is could be the quickest way for you to get better at not only what you do but possibly how you do it.

Conversely if you are a manager or perform interviews provide honest feedback as anything less doesn't actually help the person you manage/interviewed to improve.

Book Review: The Art of Agile Development

2012-06-26T08:30:00.000+01:00

I have decided to go back and re-read some of the agile books from my list of books I recommend to people wanting to know about agile.

The first book that I picked was the last on my list, it is one of the larger of the books I recommend at 440 pages so it has taken me a while to get through it although I’m glad that I have.

The title of the book is a little misleading as the book is not about general agile development but it is in fact all about Extreme Programming (XP) and its aim is to provide the reader with information based on the authors experience not only about what XP is, its practices and principles but some real world advice about agile projects.

The information in the book is broken down into 3 sections:

Getting Started
Practicing XP
Mastering Agility

In the preface of the book the authors provide some advice about who should read what parts of the book:

Merely curious about agile – read Part 1then move onto Part 2
Enough to do your job – chapter 3 from Part 1 then all of Part 2
A leader or bringing agile to your organisation – read the book cover to cover

They also point out that the book is not just for purists but that in fact if you are only concerned with writing good software the information contained in part 1 & 2 will be of use to you.

Getting Started

The first couple of chapters outline why an organisation would want to consider looking to implement agile and how you can go about introducing it with a warning about not trying to create your own methodology but to use one of the existing methodologies.

Chapter 3 is provides a high level explanation of the XP Lifecycle, XP team and XP core concepts. It is this chapter out of all the chapters in part 1 the authors recommend people should read due to its focus on explaining XP which is key for the rest of the book.

Chapter 4 provides guidance for people looking to implement XP setting some prerequisites that you should have in place before attempting to do so and some recommendations for you to follow to help you establish agile in your organisation.

Practicing XP

This part is the main section of the book making up fully 2/3 of it, it is made of 5 different chapters and covers all of the various team and technical practices that are associated with XP.

Each chapter concerns one phase of the XP lifecycle and details the practices connected with that phase:

Thinking – Pair Programming, Energized Work, Informative Workspace, Root-Cause Analysis, Retrospectives
Collaborating – Trust, Sit together, Real Customer Involvement, Ubiquitous Language, Stand-Up Meetings, Coding Standards, Iteration Demo, Reporting
Releasing – “Done, Done”, No Bugs, Version Control, Ten-Minute Build, Continuous Integration, Collective Code Ownership, Documentation
Planning – Vision, Release Planning, The Planning Game, Risk Management, Iteration Planning, Slack, Stories, Estimating
Developing – Incremental Requirements, Customer Tests, Test-Driven Development, Refactoring, Simple Design, Incremental Design & Architecture, Spike Solutions, Performance Optimization, Exploratory Testing.

Most of the sections in each chapter have what the authors call Études which are exercises, usually for the whole team, to carry out to help you understand and master the practice that is being explained. Each section also contains contra-indications which are to help you identify when you shouldn’t try to implement the practice due to conditions on your team or in your organisation.

Mastering Agility

The final part has 6 chapters, the first chapter in this section lays the groundwork for the other 5, the authors explain that they have distilled values and principles from various agile sources and found 5 themes each of which is covered in this section.

Each chapter contains some information about the theme how it often works in practice then a section called “Beyond Practices” where the authors offer advice about the theme through anecdotes of their experience in the field and how you can see that things don’t always go to plan.

Summary

The strength of this book is that you can read it cover to cover and learn all about Extreme Programming and its agile practices, but you can also use it as a reference book going back to each practice and using the Étude to improve you and your teams skills in that area.

Although this book is primarily about Extreme Programming, today you will find the majority of practices used in most agile methodologies and it is for that reason that even if you aren’t doing XP but want to know more about the various agile practices it is worth reading the book.

The one thing that did strike me on re-reading this book was the change in mindset that has happened in the agile community since this book was written, where it says you should implement all of the practices or you are more likely to fail where as today a more evolutionary approach is usually taken where you don’t attempt to implement everything immediately and build up the number practices you implement.

Due to its length reading this book cover to cover is a real commitment but if you are new to agile it is worth the investment of time, if you are already practicing agile then this book also has a lot to offer as you may discover practices you have never heard of before or find ways to improve the ones you are already doing.

Is definition of done no longer needed?

2012-05-17T08:30:00.000+01:00

A while ago now there was a discussion about “definition of done” (DoD) with critics and supporters alike commenting on how they saw DoD and need or lack of.

The critics seemed to fall into 2 categories: those that believe work isn’t done until its actually deployed to production and those that did not see a need for DoD at all, where as the supporters generally reiterated the need for DoD and tried to explain its worth (which on twitter in 140 characters can be difficult), the most memorable tweet from these exchanges came from Hadi Hariri suggesting that DoD was akin to “agile mental masturbation”.

So are the critics right? is definition done not needed?

A definition of done

Before we go any further let me offer a definition for DoD:

“A definition of done is a checklist of “things” that need to have been completed before a item is considered finished”

Each teams DoD is likely to differ from each other as they should have been created by the team to meet the requirements/constraints they have in their environment allowing them to be happy a piece of work is complete.

The key thing with DoD is that everybody involved in the story/feature understands exactly what it means to be done, so no “oh its done but I just need to do <y> first” if you say you are done then you need to have met DoD.

The arguments against

Its not done until its deployed to production

This is a very powerful statement and goes even further than XP idea of Done, Done where the code is not only written but every thing has been completed that is needed to deploy the code, now you cannot say something is done until it is actually in the hands of the users.

I can see where this sentiment comes from but would humbly suggest that it is dependent on the environment you work in. If you have a web based application the complexity and overhead deploying the latest version should be low but not everybody is developing web applications. In one of my presentations on kanban I was asked about this concept, the dev in question created software that still had to be distributed by CD so he wanted to know was his work only done once the CD’s had shipped?

There isn’t a need for a definition of done

This statement came from people who I know work in highly agile environments that are focused on delivering value to the users, one person said to me “I’ve never seen a definition of done here everybody knows when the work is done”.

For an agilista this sounds like nirvana, a team that lives agile to such a degree that they know when the work is done, no need for any checklists or wondering if Sue/Fred/thingy has remembered to do something.

I think this situation is great, but, what happens if change is introduced into the well known process? what happens when a new dev joins the team?

The argument for

For me DoD has 2 main benefits:

Transparency
Communication

If you have a DoD in place it is completely transparent about what needs to be done for any story/feature before you can say “I’m done”, this is understood by developers, project managers and other stakeholders, it demonstrates the actual amount of work that is required to complete a piece of work and that it is not just writing the code.

The DoD should be on display in a prominent position, it is there for everybody to see. If somebody new joins the team/business everybody can see what’s needed to mark a story/feature as done it is very visible for the team and it serves as a reminder of what is expected of them or to a business person what is involved in getting the work done.

The Verdict

To my mind the need for a DoD is essential, it doesn’t matter if you are doing agile or waterfall, it is having the ability not only as a development team but as a business to understand everything that is required to complete a story/feature.

The argument that its not done unless its in production is a very powerful one and as I mentioned earlier if you are in an environment where you are able to do that I would suggest that adding “deployed to production” as an item to your DoD. However, if the environment you work in doesn’t allow this then I would suggest you should be including a deployment to staging/testing/UAT to ensure that you can deploy the software and does what you expect. For me this argument doesn’t replace the need for a DoD but I strongly believe you should be thinking about the idea behind it to understand the need to deliver value to the user for the business.

I don’t believe the argument that there isn’t a need for a DoD holds any water, the only downside to having a DoD I can see is if it becomes so prescriptive that development is becomes just one of a myriad number of tasks on the list, if that is the case then perhaps the team has missed the point and needs to re-evaluate what their DoD is for.

So is DoD needed any more? Yes, and IMHO its a key part of the development process that all teams, agile or otherwise, should be looking to use if they don’t already.

Is software craftsmanship a luxury most can’t afford?

2012-05-15T08:30:00.000+01:00

I’m guessing that for a lot of developers out there the idea of software craftsmanship sounds fantastic and that they’d love to be able to do it but everyday they are facing deadlines to deliver software to a client and as such are under pressure to “just do it” rather than taking the care they would wish to.

I firmly believe that software development is a craft, whilst it has engineering principles it can at the same time be very close to art, much like a master carpenter who when creating furniture has specific techniques for creating different parts of that piece of furniture but what they produce when it is all put together is often viewed as a form of artwork.

What a master carpenter has though is usually time to exercise his skills to enable him to produce the best “product” that he can, people can see and appreciate what it is he is producing and therefore the time it takes to create it is better understood by the customer as they can see what has gone into the finished product.

Software, on the other hand, is viewed completely differently.

How did we get here?

When it comes to software how often have you heard the phrase “but its only a web page!” and here lies the problem. Software by its very nature is intangible and the customer is only likely to see whatever they interact with they don’t see all the hard work that has gone into the creation of the “product”.

Yes you the developer have sweated blood & tears to craft the software to meet your exacting standards meaning its tested, clean code that adheres to SOLID principles to ensure that not only you but those that come after you will be able to easily maintain and evolve the code base and you have delivered it on time as promised.

The issue is that because the client doesn’t see or appreciate this they don’t care. What they care about is delivery of features/stories/tasks and what they want is more of these delivered, if possible, yesterday because time is money and in the current financial climate there isn’t a lot of it around.

And the issue is?

At Agile 2011 Jeff Sutherland was quoted as saying “the iron triangle is a relic of the 20th century” and when it comes to larger enterprise development I would hope he is right, it is often far easier with internal “customers” to be able to educate them to flex the scope and ensure you deliver value to the business, but, as I mentioned in this post then in my opinion if you are working for a small software house, or dealing with external clients, the iron triangle is very much alive and you are expected to meet it.

Without the support of your management you face the very real prospect of software craftsmanship been seen as a luxury that you cannot afford, and any time taken away from delivering software the “customer” wants is not acceptable.

I can hear the howls of derision already “you need craftsmanship skills to reduce the number of bugs”, “what happens when the code changes”, etc. and I don’t disagree but I know of more than one developer that has had been told they have to deliver by <x> and the only way they feel it can be done is simply by cranking out the code and worry about the bugs afterwards. On top of this I’d hazard a guess the number of developers I know in this situation outnumber the developers who are able to exercise there craftsmanship skills by a large number.

How do we solve this?

For the most part this isn’t a developer problem it is a management problem, developers want to follow craftsmanship practices but it is the management that feel it isn’t a productive use of time.

Unfortunately the bottom line is money, and if the company you work for is focused on fixed term, fixed price contracts trying to move to using more craftsmanship practices will not be easy. It is usually these environments that use waterfall type methodologies and expect developers to hit the deadlines they are given and it may simply not be possible to change the culture of the company to a more craftsmanship oriented one.

To help you try and transition towards the right sort of environment where craftsmanship is valued you need to be showing people the value in what you want to do and to do that its about:

Education, of taking your managers and/or customers and showing them that through the use of craftsmanship skills the overall cost of software drops
Showing managers/customers all that is produced, they don’t have to understand it just be able to appreciate that it “isn’t just a web page”
Involving managers/customers in the creation process to help them feel like they are part of what is being produced not just a recipient.
Helping managers/customers to get the most value from the software so that they feel that their money is being well spent

Unsurprisingly agile methodologies value these things and place them at the core of what you are doing, if you are working in an agile environment and you aren’t doing this then may I humbly suggest you aren’t in fact agile, but that’s a post for another day.

Developing my first WP7 app

2012-05-08T08:30:00.000+01:00

Back in February I learned that Nokia & Microsoft had teamed up to provide free phones to developers that could show that they were developing applications for Windows Phone 7 (WP7), so I decided that this was too good an opportunity to miss and set about creating my first application.

I already had an idea about what I was going to write as had downloaded an application on my existing WP7, a HTC Radar, to help my son with his math but was frustrated by certain shortcomings such as no tombstoning and I believed that I could write my own app that would keep all the good parts of the existing app but sort out the things I saw as wrong.

Getting Started

As I already have Visual Studio installed all I needed was to download the WP7 SDK and I was able to start coding.

I made the assumption that I could unit test my code and added a WP7 class library (normal class libraries not useable) used NuGet to get XUnit installed and proceeded to write a failing test. It turns out I was unable to test against classes directly inside the phone application but I wasn’t overly bothered by this as I was trying to write SOLID code so added another WP7 class library and found I was able to write code to satisfy the test and I didn’t need the emulator running to do so.

I also decided to follow the principle of YAGNI and just build what I needed when I needed it rather than looking to use a framework like Caliburn.Micro so that I could get a better grasp on what was needed to build apps for WP7

Windows Phone Camp

I attended the windows phone camp which was run as part of UK Tech days in Bristol at the end of February, the day had various talks about developing for WP7 as well as a “workshop” area where you could code and receive help from experienced WP7 developers.

I attended the first talk which was all about Metro and designing an application that would fit with the metro design concept but after that I spent the rest of the day in the workshop area and I’m glad I did.

Most attendees stayed in the talks which left me with access to the likes of scottisafool, Peter Foot and not forgetting Pete Vickers so that’s 2 WP7 MVP’s and a very experienced WP7 with time on there hands which meant that as I coded during the day if I ran into a problem I could grab one or other of them to help me with my app, and I have to say I believe I made more progress with them around in that single day than I could of in solo development in 2 weeks.

I also got some sage advise from these good fellows which paraphrased was “don’t be afraid to use code behind, you can do everything in XAML but is the extra time and effort worth it to you?”

The one thing that I didn’t get from the day which I was really hoping for was a phone, but I had the details of how to apply to get one (the details are here just scroll to bottom of the links) and had a fair idea of what was needed to qualify for one.

Developing the app

Due to the simplistic nature of my UI I came away from the phone camp with the UI almost 100% complete and as the majority of functionality in the app I was writing was located in the model so I was able to use TDD to create the functionality I needed.

Where I was disappointed was that in this day and age Microsoft hadn’t created the libraries that you use with WP7 with seams to enable mocking and testing. It was because of this I ended up creating my own helper class to enable me to mock one specific interaction and necessitating a change in the design of the application to add interfaces to act as seams for testing purposes.

I was also disappointed by the fact that it is not possible to perform constructor injection on any of the XAML pages, there are alternatives (such as ViewModelLocator) but as I was adhering to YAGNI I didn’t want to have to create the locator class and any additional infrastructure so instead I decided to use Ninject and use a Service Locator pattern. Whilst I don’t normally like service locator it seemed to me to be the simplest way to achieve composable code in the way I was developing the application.

My fake/stub/mock library of choice is NSubstitute but when I tried to add the package via NuGet I got an error message telling me it was not compatible with WP7 app. I couldn’t see any real reason for this, given I was only trying to test logic, and managed to get around this by simply downloading the latest version from github and referencing it directly from my class library without involving NuGet at all.

I’d read Scott Hanselmans post "From Concept to Code in 6 hours" and looked to some of the same tools he had used in his application to help me namely:

Silverlight Toolkit – provides controls that, in my humble opinion, should be part of the normal SDK
notifypropertyweaver – just implement INotifyPropertyChanged on a class and at at build time this will add the event and all the necessary plumbing code to the properties.
Your Last About Dialog – provides all you need to painlessly implement an about dialog

There was one library that Scott Hanselman used that I didn’t want to and that was LittleWatson, not because there was anything inherently wrong with the library, as I didn’t want the user to have to send me an email with all the gory details in it. I looked around for alternatives and came across the excellent bugsense that not only provides a library to capture the error and transmit it to a web service but the web service to receive the bug report, a database to store the information and a dashboard for me to view any errors! The price for this? The free price plan gives you up to 500 errors per month and they only hold onto the data for 7 days but it satisfies my requirements at the moment.

Publishing the app

With the coding done and some graphics created for the app I submitted it to the Windows Phone Marketplace through the App Hub, which in itself was a fairly painless process and I made the app free as I believe that WP7 needs more free apps to compete with the other platforms; I have decided to keep the source closed as it was pointed out to me anybody could simply take my code and with little or no change submit it as a paid version.

My only issue with the App Hub was that once submitted I had no idea of timescales for the application to work through the stages to be published, it would be nice to have some of indicator of when the app should reach each stage to set a developers expectations.

The app took just over a day to reach the certification stage but I then had to wait a further 3 days for the certification to be complete and then to be published.

What is strange is that 3 days after the app has been published I am unable to find the app in the Marketplace if I search for it by name, instead the only way I can find it is via my name as publisher and I’m not sure why its doesn’t appear under a name search.

What now?

I’m hoping some people will download the app and get their children to try the application, after all it is aimed at kids not at adults, I’m more interested in what they have to say about the app. You can view the app details and download it from here.

I already have plans as to how to extend the application but will wait a while and see what feedback I get from the app and see what people actually what before I continue with development.

After publishing I realised that for whatever reason I never finished the description of the application and that I need a better graphic for the market place so I’m going to have to find out how to amend a Marketplace listing after the app is published to correct these mistakes.

I’m also going to investigate why I can’t find the app when searching specifically for it by name since the app has been published for 3 days now and currently you can only find it by search for me as the publisher, I will update this post if I find the reason.

Windows Phone & WinRT….why?

2012-04-13T08:30:00.000+01:00

As I mentioned in my last post my free time, when coding, is taken up with getting my first Windows Phone application completed and published.

So whilst doing this and getting to grips with WP7 development I started hearing about how Windows Phone will be changing (Mary Jo-Foley’s blog, Windows Phone dev blog) and that for Apollo, the next Windows phone OS release, Microsoft will make Windows Phone use the Windows 8 kernel.

My first reaction is why? why change it, Microsoft as a company need to get as many companies/people developing apps on
the platform to make it successful. You may hear the line “its not about the apps” but it really is, with a lot of bigger companies (like Starbucks) having and promoting apps on iOS & Android but nothing on Windows Phone the platform looks weak and that is the last thing Microsoft and Nokia need now. It seems that Nokia need Windows Phone to be a success or they may be in trouble so you would think they wouldn’t be happy with any major change that could effect the adoption of the phone.

I read the blogs and can see and understand that Microsoft wants to have a unified environment across phone, tablet and desktop/laptop but why, when you need to get people developing on a platform, do you change how they develop on it after it being out such a short length of time? Developers have invested time and effort into learning about the phone and its foibles only to now need to look to learn new technology if they wish to continue developing on the platform in the future. Microsoft have said that existing apps, legacy apps, will continue to run on the new platform but no details are forthcoming on this at the moment.

Lets be clear this isn’t a OS tweak this is a major change, Silverlight gone, you can use XAML but you have to learn WinRT, the apparent good news is you should be able to develop native apps in C++, yeah great so excited about that given I last used it in any anger about 10 years ago and was happy to see the back of it, yes I know for low level performance it rocks but for most phone apps is it really needed?

Update: I need to point out that Microsoft has said that any Windows Phone 7/7.5 apps will run on Apollo, as devs I think we have to assume that we won't have to do anything since the need to republish apps would not be a good story for Microsoft.

If anybody knows me you’ll know I’m not adverse to new technology but for the life of me I cannot understand why Microsoft would do this, at this time, when they are trying to gain traction in a market dominated by iOS & Android devices.

This now leaves me wondering if I should bother to continue to invest my time in developing apps for Windows Phone 7 or should I now just focus on learning WinRT and preparing for Apollo instead?

My feeling is that a lot of developers who may have thought about doing some Windows Phone development in their spare time will now hold off until Apollo is released and anybody doing development already probably won’t plan on creating lots of new apps either. If this does happen then you could see the number of applications in the market place stall which isn’t a good thing for Microsoft, Nokia or any other handset maker that needs Windows Phone to be successful.

Whilst Microsoft wants a unified platform, and I as I said I understand why, would it not be better to wait and be happy that Win 8 and WinRT is successful with bugs ironed out before rolling it out across all form factors?

Windows Phone 7 Test Helper

2012-04-04T08:30:00.000+01:00

Just a short post as currently all my time is taken up trying to get my first Windows Phone 7 app completed which I’ll blog about once its all done.

When I started my WP7 dev, me being me, I went TDD from the off but ran straight into an issue where I couldn’t fake the IsolsatedStorageSettings.ApplicationSettings which I’ve been using for data storage.

As I’m new to the platform I decided to live with it but last night I created code that I needed to test around storing data so I decided enough was enough and created a little wrapper class so I could fake the ApplicationSettings class.

Thus is born my WP7.TestHelper assembly where I’ll add any other classes that I find where I need to fake them for testing and you can’t do it out of the box.

As usual you can find the code in a repo on my GitHub.

NDepend – final thoughts

2012-02-06T09:00:00.000Z

Over the last 4 posts I’ve covered the different editions of NDepend, installing and starting off, the report and Visual NDepend and wanted to just wrap up this series summarising the information and adding some of my own thoughts.

The Product

I have to say that the fact NDepend offers a free version for individual developers is brilliant, there used to be several tools in the .Net world that did this but gradually they all seem to have become commercial and only offer time limited trial versions.

There is a small catch in that the version you download is time limited itself but there is nothing to stop you downloading the another trial edition (web page even tells you when the next free download will be available) but I can imagine this becoming a pain after a while and could lead people to looking for an alternative.

One thing that surprised me was the amount of help and documentation that is available on the NDepend website ranging from simple FAQ’s to video tutorials which will help with not only how to use NDepend but the information the NDepend provides.

The Functionality

As I mentioned in my post on the report when you first start using NDepend you are most likely to focus on the data in the report and although it contains a lot of information I still believe that the report is of most benefit in a CI situation allowing you to track the evolution of your code base.

In day to day work Visual NDepend or the visual studio AddIn is where I believe the most value is to be found for individual developers allowing them to identify the points to focus on.

Although you can use the stand alone application (Visual NDepend) in my opinion for most developers it is the visual studio integration that will provide the most value since you don’t have to leave the IDE to utilise the functionality.

The Code Query Language is what differentiates NDepend from other static analysis tools allowing you to understand how it identifies code that violates its rules as well as making it easy to customize existing or create new rules.

Configuration/Customization

The fact that NDepend provides a way for you to customise the rules that it runs against a code based is, I believe, one of its biggest strengths. You also get fair amount of configuration over how it behaves and looks.

However, there is no easy way to share this customization/configuration between projects let alone other members of the team. For me this is probably the biggest failing of NDepend, yes you can manually alter each project and using source control if you add the ndproj file then when the next developer pulls/gets the code they will get the settings.

A couple of issues…

One issue is that you need to care about what NDepend is showing you about your code base. There is a lot of information it provides and with the amount of help on the website it is fairly easy to understand the various metrics that NDepend rules identify and use. Even with all this information you have to care about it, for example if you have methods with a high Cyclomatic Complexity although you may understand what it means if you don’t care then the the tool is of little use.

I feel I have to mention cost, for a larger enterprise organisation the licencing cost is unlikely to be a big issue but for smaller companies & individual developers, or hobbyists, the cost of the professional edition could be just too high.

I would also mention that I believe if you want the best results from NDepend you need everybody on your team to have it as just having it on a single machine, even if its the build machine, makes it hard to then follow up and fix violations.

Summary

As anybody who knows me will know I’m a big fan of SOLID clean code and I like to be able to use metrics to understand my code and where I may need to improve it, I find that NDepend helps me with this.

It is simple to get started with but there in lies its deceptive nature as it can not only tell you a lot about your code base but you can also learn more about various principles behind good code bases (I learnt all about the efferent & afferent coupling).

NDepend is a tool that you need to spend time with to understand what it can show you and how to get the most out of it, if you do decide to invest the time I believe it will repay you in cleaner code and increased knowledge.

Note: I was provided a copy of the professional edition to review back at the beginning of last year, this hasn’t effected what I have said about the product which hopefully you can see in this series of posts.

CodeProject

NDepend–Visual NDepend

2012-02-03T09:00:00.000Z

The last post went over the report that NDepend generates, this post is going to focus on Visual NDepend, the stand alone program and the functionality it supports.

Interactive

The difference between the report and Visual NDepend (from now on I’ll just call it NDepend) is that you have much greater ability to drill down into the code base allowing you to jump between various graphs/diagrams, you can then right click on the item and jump to a different view with the specific item the focus of the graph/matrix.

NDepend Project

NDepend, in its various flavours, has its own project file which contains all the settings necessary for NDepend to function. There is no dependency to have the project file sit with code base it related to but I would suggest that it is a good idea to keep it with the solution you are analysing and check it into your VCS as well, especially if you start customising the rules etc.

Unfortunately because customizations are stored in the individual project files currently it is not easy to share any customizations across projects but in the comments to this post suggest the the makers of NDepend are working on it.

Getting started

When you open up NDepend you should feel right at home as it has the distinct look & feel of visual studio.

When you first open it you will be presented with a screen that presents you with all the things you are most likely to need – links to videos on the NDepend site, buttons to install the AddIn’s for Visual Studio & Reflector & you will also be able to see if you are running the most up to date version of NDepend.

The left hand area displays recent projects you may have worked on and provides links to create a new project from scratch or analyse existing Visual Studio solution/projects, .Net Assemblies or compare 2 code bases.

Once you’ve selected the solution/project to analyse NDepend will perform the analysis and display the results.

At this point the information that is being displayed is effectively the same as what is contained in the report, it has the summary which contains the same information as the application metrics on the report, its got all the CQL rules that were ran and an indication if they passed similar to the reports menu listing of the rules.

Analysis using graphs

At this point you are now able to start moving between the different graph’s and matrices to explore the code base. The report just had the images showing the each of the graphs with no additional information, however in NDepend these are interactive and you can get a lot more information out of them.

For example in the dependency graph hovering over any dependency will highlight the dependencies for that item and the Info panel on the right hand side will be populated with metrics about that item. When you right click you can then jump to the another view, such as dependency matrix, to see the analysis in relation to that particular view.

Analysis by CQL Rule

If you select any of the CQL rules that have been run then all of the graphs/matrix will indicate the various parts of the code base that match the rule providing a visual way to allow you to focus on the items that are violating the rules.

As well as altering the graph the CQL Query Edit will display the rule and show the classes, methods, properties, etc that have violated the code (assuming you have selected a rule that has been violated) and if you double click that item it will open the solution/project, if not already open, and display the code although this hasn’t always worked for me.

As you select the various rules and navigate the UI you can see that this way of looking at your code base is much easier as it can allow you to focus on the areas identified rather than simply drilling down into the analysis.

CQL Querying

As impressive as the analysis is in my opinion the ability to generate your own CQL queries to be able to create your own rules, all you need to be able to do is think about what you want to query. To make it even easier the query editor also has auto complete to help you to construct the queries and shows you live results as you create the query.

Any queries that you create are saved in the project file and will be run against the code base the next time that NDepend runs an analysis.

Options

As you would expect you are also able to configure a lot of the behaviour of NDepend through the GUI, such as whether it runs a full or incremental analysis, if a html report is created & displayed, etc.

There are configurable options for the majority of the functionality within NDepend even down to the colour scheme of the GUI itself and if you want to use a ribbon rather than a toolbar interface.

Visual Studio AddIn

As well as the stand alone application there is the AddIn for Visual Studio which adds an additional menu item to access the functionality that is available in NDepend directly in Visual Studio so you get the graphs/matrix, CQL explorer, CQL Query, etc without having to leave the IDE.

The one additional thing that the AddIn does that NDepend doesn’t do is to allow you to create a NDepend project for the currently loaded solution and it will add that file to solution for you.

Summary

What I’ve covered here is really only scratching the surface of what NDepend can do, I haven’t even covered code base comparison or test coverage, both of which are options available to you as well.

It is this functionality that is of real use to individual developers especially allowing you to jump into the specific bits of code that have been identified as needing attention.

The ability to create your own CQL queries to investigate your code base is great but the inability to easily share these queries/rules between projects is a issue but hopefully it will be resolved by NDepend soon.

What’s next?

In my final post I’ll be summarising what I’ve covered and have some general thoughts around NDepend.

CodeProject

NDepend – Analysis Report

2012-02-01T10:30:00.000Z

In my last post I discussed installing NDepend and getting your first report out, this post is about that report.

I’m not intending to go into every single aspect of the report as it contains a huge amount of information and the report itself provides help and assistance on nearly everything that it contains by linking to resources on the NDepend website.

Note: All details discussed are in relation to the Professional edition of NDepend, it is possible you will not see all this functionality if you are only using the trial edition

The Report

As I mentioned at the end of the last post with the Visual Studio AddIn in place when you build your application NDepend will automatically kick in, analyse the code and create a report for you detailing metrics, adherence to some standard developer rules, graphs displaying further information about the code base in different formats, etc. Your browser will be launched and the html based report will be displayed but this isn’t a simple static report as it provides the ability to drill down into various sections to look at the analysis data in more detail.

Sections

The standard NDepend report contains the following sections:

Summary – application name, report date, etc
Diagrams – dependency, treemap, etc
Application Metrics – LoC, no. of classes, etc
CQL Rules Summary – Code Query Language rules that the application has broken

In addition to these sections you also have a menu that provides access to further information about your code including an easy way to navigate the CQL Rules, I’ll go into more depth on CQL in a bit.

Summary

This section contains pretty standard stuff such as the date the report was generated, version of NDepend used, and other information about the report rather than the code. You will also find it contains links to resources specifically for beginners to help understand the report, quick tips (which seems to basically tell you to use Visual NDepend) and a link to the NDepend website.

When running the report interactively I tend to doubt if this section adds a lot of value as you most likely know everything that it mentions, however, where this section comes into its own is when you generate the report from a CI server and this then allows you to track information about the report making it easier to link report to build and refer back to it at a later date.

Diagrams

The diagrams that are included in the report are images which helps you to visualize different aspects of the code base such as its dependencies, how abstract it is, etc but that is as far as it goes as the diagrams don’t offer any type of drill down functionality.

Application Metrics

The metrics contained in this section are things such as Lines of Code, number of methods, number of classes, etc all fairly basic metrics and again if you are running it interactively may not be of much interest to you but when you have it generated from a CI build you can look back over reports and track how a codebase has evolved over time.

CQL Rules Summary

Code Query Language is unique to NDepend, it is a DSL that allows you to query your code in a similar way that you can write SQL to query databases. The report comes with many predefined rules that are executed against your codebase and with a simple green, yellow and red indicates the number of rules you’ve passed, violated or have violated a critical rule.

A quick aside a critical rule is a normal CQL query that you have marked specifically as critical and when integrated into a CI server will cause the build to break if it is violated.

For me this is the most useful section as it lists all of the rules that you have violated and provides links which take you to details of the rule, the CQL executed and a list of the items that violate the rule be it fields, methods, classes or assemblies.

Summary

When you first run NDepend and see the report it offers help for the beginner and it looks fantastic so you delve into it, however, once you’ve been using NDepend for a while for as a single user the report doesn’t offer anywhere near the level of functionality that Visual NDepend or the Visual Studio AddIn provides and I can see the report being largely ignored.

As I mentioned a couple of times where I believe the report is of real use is when it is generated from a CI server and provides a really good way to track how a code base evolves over time, as well as ensuring that the quality of the code base meets defined rules. I’m not intending to cover how to integrate NDepend with your CI Server as the NDepend website has really good details on how to do it here.

So you can see what a report looks like I’ve created a report based on my ADO.NET DAL and you can download the files from here, then all you have to do is unzip to a folder and open the NDependReport.html.

What’s next?

In my next post I’m now going to look at Visual NDepend and go through the functionality that it provides.
CodeProject

NDepend–getting started

2012-01-23T10:30:00.000Z

In my last post I outlined the various editions of NDepend that were available, in this post I’m going to go through the install process and first steps with NDepend

Installing

Open up the Extension Manager in Visual Studio (Tools –> Extension Manager) and search for NDepend, you should then see the following:

Unfortunately if you click the button you won’t get an installer open to install NDepend instead your browser will open on the download page of the website where you will need to provide an email address to download the trial edition or the Licence ID that you have received to enable you to download the Professional edition.

When you have provided your email or your licence then you will download a zip file which contains everything you need, all you need to do is extract the files to your location of choice.

Configuration

Whilst you are now able to use NDepend standalone to get the most out of it you need to enable integration with Visual Studio. To do this run VisualNDepend.exe and select “Install Visual Studio Addin”

When you click this you will be shown a dialog that will allow you to select which editions of Visual Studio you want to install the AddIn for and the AddIn will then be installed into the appropriate versions of Visual Studio and that is NDepend configured and ready for use.

Sharp eyed readers will notice the button “Install Reflector AddIn” which, if you have Reflector installed, will add an AddIn to reflector which will add a couple of context menu items in reflector allowing you to jump between Visual NDepend and Reflector to explore the code. Unfortunately I’ve not had a lot of success with this AddIn and am currently in contact with NDepend support to try and rectify the issues I’m experiencing.

Getting started

With NDepend on your machine and the AddIn installed when you open Visual Studio you will find NDepend as a menu item, this will provide you with one of the main ways to interact with NDepend.

To now try out NDepend simply open any project you have and then go to the NDepend menu item and select “Attach New NDepend Project to current VS solution”, this will open a dialog with the current project already added, simply click Ok.

NDepend will start up and run an analysis of the project creating a html report with the results which it will then display in your default browser along with a dialog that offers advice for new users and suggest what you might want to look at next. You’ll also find that the dialog provides a snippet of information about the options to help you decide.

Summary

Installing NDepend is very easy with very little to go wrong

My one criticism is that it isn’t an integrated process, you have to download it, then open the application and select to install the VS AddIn I know its not exactly a difficult to do this but It would be really good to be able to do the whole install from the VS Extension manager, including the VS Add-in.

What’s next?

Next I’m going to go through the report and look at what the report shows you and the information it contains.

An introduction to NDepend

2012-01-17T10:30:00.000Z

This is a series of 5 posts about NDepend:

Starting with an introduction....

If you are anything like me then you love to have information about the code you write whether its test coverage, cyclomatic complexity, or other metrics that can give you some insight into your code.

Before the shouting starts I’m not talking about metrics as KPI’s or using them for targets that developers have to meet, I’m simply talking about information you can use to better understand your code which may in turn help you to improve the code.

If you are lucky enough to have the Premium or Ultimate edition of VS2010 or VS2008 Team Suite/Developer then you get this functionality as part of visual studio, if not then you need another tool to provide you with this information. Even if you do have the native VS analysis functionality you may find that there are tools out there that provide a lot more information that the built in tools.

NDepend

NDepend is one such tool it provides metrics on your code but that isn’t all, it will allow you to delve inside the architecture of your application, allow you to diff the code, has test coverage analysis and build server integration built in.

NDepend will also work with VS2005 upwards and as it can be used independently of Visual Studio you can actually use it even if you only have the Express editions of Visual Studio.

Disclaimer: I do not work for NDepend but I was lucky enough to be provided the software to “play with”, my opinion in this and any subsequent post is my opinion and nobody else’s.

I'm going to put together a series of posts, this being the first, on NDepend trying to give you an idea of the product and what you can, and can't, do with it.

In this post I’m going to talk about the different editions of NDepend and give some information on each of them:

Editions

Currently there are 3 editions of NDepend:

Trial/Open-Source/Academic Edition
Professional Developer Edition
Professional Build Machine Edition

Trial/Open-Source/Academic Edition

The Trial/Open-Source/Academic Edition, referred to as Trial from this point, is a good starting place for anybody interested in trying NDepend.

As you may expect though this edition has limited functionality but to be fair to NDepend it provides the majority of features that the Professional Developer edition does so you can get a really good idea of what you can do though there are limitations imposed on the level of functionality supported for each feature.

You are able to use the trial version freely for non-commercial software but it is time limited (current downloadable version will stop working 12th March 2012) although you are able to download another version once the software has past its expiry date. The site provides guidance on using the trial version so you can decide if you really should be using it or not.

Professional Developer Edition

This is the full version that you’ll really want if you like NDepend, not only does it provide unfettered access to the majority of the functionality in the software (more on this in a bit) but also comes with additional features:

Test coverage import – happy to use NCover or Visual Studio Coverage
Reflector integration – provides an addin to reflector to allow you to jump into NDepend from a context menu entry
Build Comparison/Code Diff - provides a way to diff code & builds to understand what’s changed

This edition is the one you’d most likely use day to day to check on how your code is doing and to be able to target any areas that you can see could do with some attention.

Professional Build Machine Edition

If you have a Continuous Integration server then you can enhance it with this edition that will allow you to generate reports from NDepend in your build process on the quality of the code when compared with the metrics you’ve defined.

This integration will not stop your build, it will only generate the report that you have configured.

Edition summary

Above I’ve given you a run down of some of the differences between the versions and what they do a full comparison can be found here on the NDepend site.

As I eluded to the professional version doesn’t appear to support some of the features that the trial version does namely those related to build server integration.

I can understand why this has been done as it allows people to download a single version of the software and try out both the interactive and build integration facets of the application.

It would be nice though to be able to get the Professional edition to do this functionality even if only for trial purposes, it is possible it already does this but the aforementioned comparision chart seems to indicate that it doesn't have those features.

What’s next?

The next post will probably just be a short one as I’m going to be looking at the installation of NDepend.

2011 into 2012

2012-01-03T10:30:00.000Z

Just as I did in last years post this post is effectively a retrospective on 2011, including looking at whether I achieved what I wanted to achieve, and some goals for this year.

2011…

Goals

In my post from last year my goals were:

More user group presentations
More book reviews
CSP application approval
Increase amount of code I write including look at Ruby & F#
Continuous Integration
Earn MVP

So how did I do?

More user group presentations
After being selected for DDD9 I then went on to present at almost every DDD event during the year only missing out on DDD Belfast and DDD Dundee. I also got to present at a couple of user groups it may have been more but being honest I don’t think I put enough effort into letting people who run the groups know that I was available.

One event that I did participate in, and hadn’t anticipated being part of, was the Progressive.Net Tutorials at Skills Matter where I presented So you think you know agile which I enjoyed immensely.

Book reviews
I only managed to do a single book review last year on the excellent Dependency Injection in .Net but for reasons that will become apparent I never managed to find the time to do any more reviews.

Unfortunately I didn’t manage to do a lot of reading this year only perhaps having read 3 books the whole year.

CSP Application approval
My application was approved, I am now both a Certified Scrum Master and Certified Scrum Professional the latter to me being more important as it demonstrates an actual working knowledge and experience of Scrum rather than having just taken a course.

Increase amount of code I write
I can confidently say I succeeded in this, partly because I changed job again this year, which for me is very unusual to stay in a job for such a short period of time, and my focus changed from team leadership/management to near enough pure development. This change in job did mean that I no longer commuted by train I had so I lost that time.

I also worked on my own code that I pushed to GitHub and much to my surprise and delight a couple of my repo’s have been forked by other people so it would seem I may be dong something right.

One thing I didn’t spend any time on this year was the OSS project I mentioned in the 2010 post and this will be because of the other code I worked on during the year.

I never managed to look at either Ruby or F# my time being taken up with the code I wrote and pushed to GitHub and also because I simply forgot that I had set myself that goal.

Continuous Integration
When I moved jobs I got the opportunity to start using CI and moved from simply automating builds to build and test then build, test & deploy and finally added in the in built code coverage support to show the test coverage of the project being built.

My experience has solely been with Team City because I found it very easy to work with, especially with help from Paul Stack when I ran into a few issues who helped me sort them out and get everything moving smoothly.

Earn MVP
Well I failed at this utterly. I have no idea how you get onto the MVP program and didn’t even attempt to find out.

What else went on?

This Blog
When I look back at the blog I noticed that I posted far more posts in 2010 than I did in 2011 30 vs 52 but interestingly from the limited metrics that blogger provides the traffic has increased (I have Google analytics in place now but still won’t give me a full years stats).

The blog also changed from being purely a brain dump to expressing an opinion on a subject, such as Software Developer != Zen Warrior, and telling people about the code I started to push onto GitHub.

Give Camp UK
This was a massive event, where developers gave up a weekend to create software for charity. A note here is nowhere near enough to cover it but hopefully my post has sufficient detail.

… into 2012

I’m again looking to the future here to set myself some goals to try and achieve during the year and this time I’m keeping a note of them on my own kanban board so I can track how I’m getting on.

Blog posts – I’m looking to continue writing blog posts with a series of posts on NDepend coming up soon.
Read books – I have a list of books that I want to read and am going to try and make time to do so
Presentations – I have a couple of presentations I want to write and am looking for inspiration for other subjects
MVP – even if I’m not able to earn one I’ll at least look into how you go about becoming eligible for one.
Coding – I’m splitting my goals into will do and nice to do:

Will Do

Concerted effort to finish the OSS project I started about 2 years ago
Improve my JavaScript – looking at the future of development I know I need to improve my JavaScript skills
Continue working on my ADO.NET DAL, I have some ideas about it including changing the API

Nice to do

Nuget – I would love to put a Nuget package together and get it published
Learn PowerShell – it seems PowerShell could be massively useful so if I’m able to incorporate learning it in my normal coding activities then I’ll do so.
Learn Python – over the last year I have seen more and more articles, tweets, etc about python so fancy having a go at coding with it.
Develop WP7 apps – having purchased a WP7 I would love to be able to develop applications for it.

Now looking at the list I’m already thinking I’m going to be very busy and will need to get some brownie points in with the other half to try and get some time to do all this.

So if you’ve read this far you know what I’m going to be doing in 2012 but what will you be up to?

A generic repository

2011-12-31T21:37:00.001Z

Way back in January I said that I was going to post on a generic repository, due to various other diversions during the year I never managed to get around to completing this work but on the last day of the year it is finally all done and to tick off one of my goals here is the post about it.

What’s it all about?

When talking about both Linq to Sql (L2S) and Entity framework (EF) you will frequently hear developers saying that they will be using a repository to encapsulate the ORM interactions, what this means in practice is hiding the actual ORM functions and providing a abstract class or interface you can mock to make it easier to test your applications.

The simplest way of doing this is simply creating a class per entity that implements an interface and allows you to mock/stub/fake the interactions with the ORM allowing for easier unit testing of logic.

Hasn’t this been done before?

Yes it has. There are lots of articles on the web in relation to creating repositories and in particular generic repositories.
The majority of the articles I found were around EF but there were also versions for L2S and NHibernate.

So why did you create one?

At the time I started to create my own generic repository I had been using L2S for a while but found it frustrating that although it was useful it made testing very difficult as there was no easy way to mock/stub/fake it.
So I decided to try and create my own, yes I could have just used one that was already on the internet but doing that I wouldn’t have really thought about what was needed or what issues I could encounter.
It would be very churlish of me to pretend that I hadn’t looked at other peoples implementations especially since the issues I was running into may have already been solved by other people (this post in relation to the L2S implementation and this post in relation to the EF implementation).

Does this code offer anything different?

My code has been designed to work with dependency injection and because of this each repository class does not create the context it needs rather it expects it to be injected into it. Its not revolutionary but does allow the developer to control the lifetime of the context rather than relying on the repository to do so.
The implementations for L2S & EF have been designed to work with entities that have been disconnected from a context rather than simply expecting all the interactions to be done within the scope of a single context which is often an issue in
n-tier applications.
A fair number of the generic repository implementations I found on the web expected you to not only specify the type but also the primary key, my implementations will attempt to determine the primary key of the entity itself removing the need to specify this.

Why use generic repositories?

The advantages

Generic repositories are perfect when building applications using TDD and you need to be able to mock/stub/fake the ORM as a dependency. It is also possible to take a lot of boiler plate code (such as updating changes in a disconnected scenario) and push it into the repository so keeping the code DRY and adhering to SOLID principles.
The other major advantage is the ability to inject the ORM dependency into other classes allowing you utilise IoC containers to construct whatever object graph is required.

The disadvantages

The generic repository as I, and most other examples, have implemented it is a leaky abstraction as the entities in the ORM are what the rest of the code uses thereby creating a tight coupling between the application code and the specific ORM. This may or may not be an issue for you depending on whether you are happy to be bound to any specific ORM or if you truly want persistent ignorance.
Although the generic repository offers a lot of control if your entities contain child objects you still don’t have control over it when how those are loaded, they are still loaded by the ORM and potentially if the entity has been disconnected you could have errors to contend with as it tries to load them without a context.
By encapsulating the ORM behind a facade interface it is possible you will lose some (all?) of the in built functionality that the ORM provides (self tracking entities is one possible loss) which could render the advantages of using an ORM null and void.

Summary

Whilst writing this code it struck me that the generic repository is an imperfect solution to the problem of mocking/stubbing/faking an ORM to reduce the coupling between the layers and since I first starting looking at this various solutions have come about – EF Code First, micro-ORM’s (Massive, Dapper, Simple.Data) and these provide a better solution BUT they rely on dynamic and if you are still working with .Net 3.5 this isn’t available.
So if you’re on .Net 4 (or above) then look to one of the newer version of ORM or micro-ORM that will easily allow you to mock/stub/fake the data access without the need for this additional coding, however, if you are working with .Net 3.5 then a generic repository may just be what you need to enable you to utilise an ORM, unit test the code and use IoC to create your object graph.
The code itself is available to download from my GitHub, please go here to download it.
Note: the code has been written in .Net 4.0 whilst L2S is happy to convert to .Net 3.5 the EF implementation will need rewriting to work.

A S.O.L.I.D data access layer

2011-12-06T10:00:00.000Z

A while back I had reason to look at one of my assemblies in my “toolbox” which wrapped the System.Data.SqlClient assembly and as often happens when you look at old code you cringe and wonder what you were thinking when you wrote it, so I decided to refactor the code using S.O.L.I.D principles to make the code easier to understand, test, maintain and extend and so ADO.NET DAL was born.

For those of you who follow on me on Twitter you’ll know I spent a long time trying to ensure that the library had 100% code coverage but unfortunately I never made it, one method still eludes me but 99% coverage is pretty good .

A data access layer? really?

In this age of ORM’s, micro-ORM’s and Simple.Data are people still using ADO.Net directly? are people writing data access layers which don’t return a fully populated POCO? I can safely say yes to both of those questions having seen code with numerous native ADO.NET calls and various blog and tweets from people that don’t like or want to use an ORM.

For some people ORM’s are seen as an anti-pattern which actually hinder development as a project becomes more complex, for other people they may be dealing with legacy software that uses ADO.NET extensively and this use of native ADO.NET makes the code hard to test and often the amount of effort required to refactor it is so large it is just left as it is.

Why should I use it?

If you are working on legacy software which has ADO.NET code scattered throughout the codebase you’re working on this library should make it easy for you to refactor the code without taking a lot of time, allowing you to write tests for it, and making the code a lot cleaner in the process.

If you don’t want to use an ORM then this library has wrapped the ADO.NET functionality in a nice package that you can just use meaning you don’t have to worry about connection handling, transactions or creation of parameters.

What does it do for me?

As mentioned above the library is designed to deal with connection handling, all that you need to do is to provide the Sql, or name of the stored procedure, you want to execute to the appropriate method and the library create the command object, configure it and execute it for you.

The intention behind the code is to simplify the use of ADO.NET by wrapping the boiler plate code and just exposing the core functionality through a facade meaning you can focus on the what you want your code to do rather than the how.

If you have native ADO.NET in your classes you can simply replace blocks of code with calls to the appropriate methods, this means you need make only the minimum of changes to the overall structure of your code without worrying about side effects.

The library is test friendly making it easy to mock/stub/fake the interaction between your code and the database and by ensuring that the code can be tested it is also easy to inject into any classes that may need it using your favourite Inversion of Control container.

To further help with testing the public API uses the System.Data.Common namespace which is designed to work with various data providers and all support generic interfaces that can again be mocked/stubbed/faked.

Show me the code….

Here is an example of some pretty standard ADO.NET code that you may find in many code bases:

using (var connection = 
        new SqlConnection(ConfigurationManager.ConnectionStrings["theDatabase"].ConnectionString))
{
    var command = new SqlCommand("GetValue", connection);
    command.CommandType = CommandType.StoredProcedure;
    command.Parameters.Add(new SqlParameter("firstParameter", parameterValue));
 
    connection.Open();
 
    result = command.ExecuteScalar();
}

The code above also has a dependency on ConfigurationManager, whilst I’m not saying this is always the way the configuration string is provided I’ve seen it more times than I’d care to remember.

So what does this look like with the DAL?

   1: result = dataAccess.ExecuteScalar(storedProcedureName,
   2:                                   dataAccess.ParameterFactory.Create("firstParameter",DbType.Int32,123));

you can accomplish the same in a single line…ok so I cheated a little and missed out the creation of the dataAccess object itself but that is just:

   1: IDataAccess dataAccess = new DataAccess(connectionString);

and if you are using dependency injection you’d get your IoC container to do this for you (you are using IoC aren’t you?) which means that you won’t have it scattered throughout the code base.

If you look at the code you’ll see that the main IDataAccess interface has a ParameterFactory object that you use for creation of any parameters that you may need, and because the method calls all take a param array of DbParameters you can simply add more and more in the method call like this:

result = dataAccess.ExecuteScalar(storedProcedureName,
                                  dataAccess.ParameterFactory.Create("Parameter1",DbType.Int32, 123),
                                  dataAccess.ParameterFactory.Create("Parameter2",DbType.AnsiString,"a"),
                                  dataAccess.ParameterFactory.Create("Parameter3",DbType.Double,"12.01"));

But equally because its a param array you can call the same method with no parameters at all:

   1: result = dataAccess.ExecuteScalar(storedProcedureName);

Anything else I should know?

The library also provides a basic unit of work implementation through normal ADO.NET transactions:

dataAccess.Transactions.BeginTransaction();
  
try
{
    int id = dataAccess.ExecuteScalar(doUpdate, dataAccess.ParameterFactory.Create("1",DbType.Int32,1));
  
    dataAccess.ExecuteNonQuery(doUpdate2,dataAccess.ParameterFactory.Create("id",DbType.Int32,id),
                                         dataAccess.ParameterFactory.Create("value",DbType.String,"abc"));
  
    dataAccess.Transactions.CommitTransaction();
}
catch (Exception ex)
{
    dataAccess.Transactions.RollbackTransaction();
    throw;
}

The other feature that you may want to be aware of is that each method has an overload that allows you access to the actual DBCommand that was executed so that if you need to get to the return value, return parameters or anything else on the command you simply provide an out parameter to populate:

   1: dataAccess.ExecuteNonQuery(out commandToCheck, storedProcedureName);

Future plans

At the moment the library only supports Sql Server as that was the focus of the original library that I refactored, however, I’m hoping to extend the number of types of database the library supports going forward with the first additional type of database being Sql Compact.

This seemingly simple change will offer plenty of challenges as I would like to keep the public API the same meaning I have to work out which type of database you want under the covers, quite how I’m going to do that I haven’t decided yet.

Feedback please

I’d love to hear your thoughts on this, is it something you like? is it something you think you could use? would I be wasting my time extending this further given alternatives that are out there?

Please leave me a comment or contact me about it and feel free to fork the code and have a play.

Getting to grips with a Windows Phone 7

2011-11-29T08:30:00.001Z

Last Wednesday I became the owner of a windows phone 7 (WP7), a HTC Radar to be precise. My current mobile contract had expired and I had been toying with the idea of getting a WP7 for a while. Unfortunately I was dubious about the platform and didn’t really want to take out a long contract and end up with a phone I didn’t want, and as all my attempts to get a free phone failed I decided to try and buy a SIM free phone. A brand new phone was beyond my budget so I turned to eBay and found a few WP7’s listed and managed to pick up a Htc Radar for about £200 which was a result.

Why a WP7?

I have already been asked why I’d want to buy a WP7 and the simple answer is that I am a .Net developer and I want to do some mobile development, not just on the emulator but to be able to actually deploy to the device for testing and ultimately the market place. Whilst I’d already got an Android phone (HTC Desire) I was faced with having to find time to learn java or find the money to buy MonoDroid neither of which were likely to happen.
By having a WP7 I should be able to use my existing skills and create mobile applications without a big learning curve or shelling out extra cash which in theory makes it the ideal choice for my first native mobile apps rather than simply a web application that is able to run on mobiles.

Initial impressions

The phone itself seems a nice piece of kit, reviews on it generally like the radar but tend to mark it down on storage and speed but so far with what I’ve being doing I’ve not experienced any noticeable performance problems. As I use it more storage may be an issue but with 8Gb internal storage (double my Desire’s standard 4Gb SD card) hopefully it will take me a while to fill it up.
The setup was easy, walked through a short wizard with my existing SIM and the phone was working! The only thing I didn’t like was the phone “needing” my Windows Live Id to work and then trying to get me to link it to any and all social networks that I may be part of, call me old fashioned but I tend to keep them separate for a reason and don’t really want Windows Live being linked to all of them.
First thing I wanted to do was customize the phone a little, my own widgets, ringtones, etc. Imagine my disappointment when I found the most I could do was alter what tiles appeared on the first screen and all my other apps appear in list only if I swipe to the left, this certainly wasn’t the user experience I was used to on my desire.
It felt like that every application I opened wanted to be able to use my location and transmit that information to Microsoft which I didn’t want to do so I kept having to say no.
I found the WiFi setup and connected to my router and the phone proceeded to download any contacts I had in Windows Live, which is very few to say the least. I then setup my Gmail and the phone also pulled down my contacts and populated my “People”

The Marketplace

With basic connectivity and contacts sorted I proceeded to to Microsoft’s Marketplace to try and get the same or similar apps to those that I already had.
It was at this point the I noticed the first big difference between Android and WP7 in that it seemed the majority of the highest rated apps available were all paid apps. Don’t get me wrong I have no issue in paying for good software its just that my impression with Android is that the majority of the apps I have and use are free.
It surprised me how many apps were paid apps, I thought (naively) that as Microsoft wanted to grow the platform as quickly as they could they would have followed the Android model instead it seems that they have decided to mirror Apple’s approach.

Apps & Widgets on WP7

Once I had found some apps that I wanted, namely a twitter client, I wanted to try them out and this was my second big difference between Android and WP7 apps generally do not auto refresh or notify you if there are updates to information e.g. tweets. To me this seemed like a massive step backwards, I was used to opening a twitter client and new that when new tweets arrived it would provide both audio and visual cues to tell me updates had been received. I know there are some apps that I have been told do have live tile and toast notifications but I haven’t tried them yet.
I also found that a few of the apps/widgets I use weren’t available such as the power bar, I like to be able to turn the various functions like WiFi, Mobile Internet, Bluetooth,etc on and off as I want them and on my Desire the power bar allows me to do this but unfortunately there doesn’t appear to be anything remotely similar on the Radar.
I had a brief twitter conversation with Phil Jones and JonAlb both of whom own WP7 and John has already developed applications and published on the Marketplace about the situation and it would seem that some of the things I took for granted on my Desire (such as auto refresh of data in the background) aren’t quite there yet on WP7, they are coming but not there yet. John also went on to point out that I am unlikely to be the target market for the phone and that for the majority of people the things I felt were missing wouldn’t even be seen as an issue.

PC Software

The phone told me there was an update available for it and it needed to be connected with the PC to enable it to be updated, so the next day I plugged it into my PC and Windows downloaded and installed the Zune software.
The Zune software seems easy to use and works well with the phone and compared with the HTC sync that I had for the desire I must say I prefer the Zune software. That being said with the Desire I had the opportunity to just mount it as a USB drive which I don’t get with the Radar so the Zune software will need to be good to overcome what I currently see as a limitation.

Using it as a phone

I know its sacrilege but I do tend you actually use my phone as a phone to make phone calls and send texts and for doing this I can’t fault the phone, it works very well. The only issue I have with it is that with the power/USB socket being on the side I am unable to use my car phone cradle to hold the phone and connect a charger at the same time. It may just be me but most phones tend to have the socket at the bottom of the phone and so it is a little strange to see it on the side and unfortunately means I either will have to buy a specialist car cradle or simply have the phone lying around the car if I want it to be charging whilst on the move.
I was also very pleasantly surprised to find that the Radar comes with voice recognition as standard so when driving I can click my Bluetooth headset and just speak the name of the person to ring, then as I was driving to work a text arrived and the phone read it to me and asked if I wanted it re-read in case I missed something, now that I like.
The one thing that I have been unable to do is to set a custom ring tone based on an MP3 ring tone I had on my desire, now I don’t think that its being overly geeky to want to set a ring tone to an MP3 but after following Microsofts online instructions and then watching a 3rd party YouTube video on how to change the ring tone I still wasn’t able to do it. This seems way to hard for such a simple task and I sincerely hope it become easier in the future.
Edit: I managed to get my ring tone working, what wasn’t clear was that when you set the genre on the track so that the phone will recognise it it has to be the text ‘ringtone’ if you don’t put that exact text the phone will not see it.

What’s next?

My first thoughts were “I can’t use the phone” but I’m persevering and have been rewarded by discovering things such as the voice recognition, and my thoughts now are that since I’m a developer and I believe there is functionality missing from the phone I’ll need to roll up my sleeves and write the software that I want.
I plan to write a few more posts on how I find the phone over the next couple of weeks and hopefully soon I’ll be able to post about my experience in creating apps for WP7.

The resource cannot be found - /Account/Login

2011-11-22T08:15:00.000Z

I ran into a problem the other day that I could find very little information about so I thought I’d put a blog post together to

a) remind me
b) hopefully help anybody else who runs into this problem.

I picked the obtuse title as it is very close to the ambiguous error message I got and should hopefully help other people find the solution far faster than I did.

Recently I was working on a MVC3 application, it was working well and I wanted to sort out dependencies for our CI server so that we didn’t need to have MVC installed on the server for the code to build and intended to do this by adding bin deployable dependencies.

I made a couple of small changes to views, a controller change to home and then clicked “Add Deployable Dependencies…” and when the dialog appeared I selected ASP.NET MVC

I then did a quick sanity check of build, run tests and run up the application before checking in only to find that when I ran the site up I got a yellow screen of death:

WTF! the unit tests had all passed and I had been testing the views themselves a moment or two ago by logging in and using the site. Unfortunately I hadn’t just made a single change since I last checked in (my bad) so I went back and checked all my changes one at a time to ensure that none of my changes could be causing the problem and found nothing.

I then took a closer look at the error and saw that the URL it was trying to request was /Account/Login which was incorrect as the name of the view that handled logging in was called Logon. I checked the web.config and the found the default values hadn’t been changed:

I then tried changing Account to something as abstract as ABCDEF but got a similar error only instead of the requested URL being /Account/Login it was now /ABCDEF/Login. Something was incorrectly getting involved when redirecting to the loginUrl and altering the route to replace Logon with Login.

I then turned to Google and found…nothing, well nothing that seemed to apply to me that is.

This only left me with the unthinkable, could it be something to do with the deployable dependencies? I took a closer look at the assemblies that had been added and saw System.Web.Helpers.dll in the bin deployable folder which I know is linked with Web Matrix. I then did a bit of exploration with Reflector turned up no particular dependency on this assembly to any of the other bin deployable dependencies or any of my referenced assemblies and so I removed it and the site started working again!

A bit more focused Googling then turned up that the behaviour I was seeing was linked to SimpleMembership in WebMatrix, I also noticed that if you look at System.Web.Configuration and the FormsAuthentication class you will find that the property LoginUrl has a default value of login.aspx. I haven’t specifically tracked it back to this but it is suspicious and would certainly fit the behaviour I was seeing.

In my second Google attempt I had also found that if you don’t want to remove the assembly you can add
<add key="enableSimpleMembership" value="false" /> to the AppSettings of your web config and this will also allow the site to work, but why do you have to add this at all?

From forum posts and some blog posts I found it appears that you would perhaps use System.Web.Helpers in MVC if you wanted to use one of the helpers that you find in WebMatrix such as the Twitter helper and that the SimpleMembership provider was being called by default rather than the normal authentication mechanism in MVC resulting in the behaviour I was seeing.

IMHO when you add the bin deployable files in VS that includes System.Web.Helpers it should either:

a) add the missing web.config AppSetting for you
b) not add the assembly if its not needed
c) add the functionality without the need for the setting

Hopefully this post may help somebody else who stumbles into this issue and save them the time it took me to work out why my working code suddenly became broken.

What type of team leader are you?

2011-11-16T08:30:00.000Z

For a lot of developers the team leader position is a coveted one, it is as if when you become team leader the business is acknowledging you and your skills, but unfortunately for a lot of developers that reach this position it is not always what it seems.

From my experience the team leader role will usually fall into one of the 3 following categories:

Team leader as Development manager
“Normal” Team leader
Team leader as technical lead/architect

Lets take a quick look at what each of the categories entails.

Types of team leader

Team Leader as Development Manager

This type of role is often sold as the next type, “Normal” Team Leader, but due to organisational pressures (expectations?) you will find no time available to do any coding, instead you will be pulled into endless meetings, have to deal with process, policy, HR, etc.

If you decide you want to take a more managerial career path this role will suit you down to the ground, with communication often being the main skill you will need as you will most likely be expected to act as translator to the business in relation to software development and how it benefits/impacts the business.

On the other hand for those developers that love to code this is the worst type of role they could end up in and will quickly destroy their morale and crush their soul.

“Normal” Team Leader

The “normal” team leader is where you are told that the role is 50-50 with half your time being spent doing managerial tasks and the other half coding.

This is often seen as a good compromise by developers as they go into the role expecting to be able to keep hands on coding but accepting the need to perform management related work as a necessary evil.

Frequently though this role turns out to be a little unbalanced in relation to the amount of “management” that is needed and it may become 70-30 or even 80-20 in relation to managerial work vs coding.

Team leader as technical lead/architect

The nirvana of developer jobs, all of the prestige, all the authority but no management related work.

This type of role with near 100% coding (not 100% as we all end up in meeting of one sort or another) is, in my experience, very rare.

A technical lead role is often an additional responsibility that is given to a senior developer in relation to a project, not a promotion with appropriate salary and benefits. An architect role usually needs the person to be spending a lot of their time talking to people either in a technical or business capacity which will reduce the amount of time they can code (but I firmly believe that architects should code with the team).

What’s my experience?

In my career I have experienced both the “Normal” team leader role and the Team leader as Development manager and it was my experience with the latter role that prompted me to take a step back from the managerial career path. I found that to keep my enthusiasm and morale I had to do a lot more coding in my own time which was to me a clear indicator of what I actually enjoyed doing.

Do you recognise your role?

Have I captured your role in the 3 types above or do you have a completely different role? If you have a different type please leave a comment with the details.

So, what type of team leader are you?