DDD Scotland 2016 – A sunny day in Edinburgh

Saturday saw an early start to travel from the north east up to Edinburgh for the first DDD Scotland in a number of years and the hashtag was already seeing activity, so it was clearly going to be a good day.

First, and only, disappointment of the day – no coffee at the venue for breakfast!  They made up for it later in the day, though a cup of rocket fuel would have helped after starting at 5am.


Some very good talks, and some real takeaways from the day – as with any event of this type, a re-firing of the engines is definitely part of the aim – new ideas, new directions, new approaches – and the day most certainly delivered on this.

I was particularly impressed with the guys from Skyscanner – both culturally and technically they have identified their problems well, and effectively delivered solutions and organisational change in order to minimise pain – a success story in the making.

A Squad Leaders Tale – the Skyscanner squads model

Keith Kirkhope (@kkirkhope)

The squads model from spotify has been widely discussed and is a model that Skyscanner has adopted (and adapted) that model during a period of organisational and architectural change, and it would appear that they have done so to good effect.

They had the typical growing pains of any organisation that has gone from early success and grown significantly really:

  • They’d hit product gridlock
  • Their source control/release process was unwieldy
  • They were broken into functional teams (front end, etc. etc.

They were able to apply a lot of thinking around the theory of constraints, and indeed highlighted that they realised they were only as fast as their slowest unit. 

They adopted the squads model, though included a few modifications to better fit their organisational structure (they included squad leads at the top of each squad, but also brought in a tribe lead, a tribe engineering lead, and a tribe product lead to give better oversight across each squad).

Each squad is essentially self managing and self directing – they come up with their own goals, metrics, and success criteria (and example given was ‘to help users find their ideal flight(s) and book it as easily as possible’)

Some really positive side effects from this empowerment – for example, project leads become redundant, the product owner becomes one of the key foci.

I managed to ask a number of questions in this talk to better grasp the model, though unfortunately the one I didn’t ask was around Conways Law.  This organisational change seemed to be fundamental to their move from monolith to micro services, and I suspect without it they could not have so effectively broken down that monolith.  This change was a top down led change, and it’d be fascinating to learn more about the drivers behind it.  It’s the first time I’ve seen the direct impact of the communication structures of an organisation directly impacting the design of the systems.

Breaking the monolith

Raymond Davies (@radyrad88)

Another talk from Skyscanner, this one a very detailed history of skyscanner’s journey from inception through to current day and covering a great deal of the technical decisions made along the way – some of which I shall investigate as part of our own journey at tombola as we face some similar issues/growing pains.

They moved from classic asp, through webforms/mvc, to mvc, and eventually arrived at their current architecture which is evolving towards a micro service model.

Some key takeaways from this one:

  • Aggressively decommission older/legacy ‘kill it with fire’
  • Theory of constraints played a bit part in their evolution
  • They weren’t affraid to look at alternative team structures and architectures

Some technologies to look at:

  • varnish and esi, riverbed traffic manager

This and the squads talk were the high point of the day for me.

Other talks

Windows brings docker goodness – what does it mean for .net developers (Naeem Sarfraz)

A great talk and the speaker was very knowledgeable – the current state of the nation for docker looks good.  Certainly not yet at the point where you’d want to deploy (far from it), but the technology is maturing nicely.

Versions are evil – how to do without in your APIs (Sebastian Lambla)

The holy wars on RESTful endpoints, and his points were very well argued.  Worth seeing the video below.

Slides From Talks

ASP.NET Core 1.0 Deep Dive – Christos Matskas

You Keep Using the word agile… – Nathan Gloyn

Versions are evil – how to do without in your API – Sebastian Lambla

“Advanced” Functional Programming for Absolute Beginners – Richard Dalton

CQRS and how it can make your architecture better – Max Vasilyev

Ladies and Gentlemen the plane is no longer the problem – Chris McDermott

Breaking the Monolith (video) – Raymond Davies

BuildStuff Lithuania 2015

Just returned from a fantastic trip to Lithuania to attend BuildStuff 2015 and thought I’d get my notes down into a blog post to help distill and to build a brown bag session for the team at work.

The focus this year seems to have been heavily around a few key topics:

  • Functional programming played a big part and it was clear from even those talks that weren’t functional that there is a shift across to this paradigm in a lot of people’s work.
  • Agile process and approaches featured heavily as an underpinning, and indeed one of the best talks of the conference for me was Liz Keogh’s talk on ‘Why building the right thing means building the thing right’
  • Micro services (micro services, micro services, micro services) is still the hipster buzzword, though at least there were hints that the golden gooses’ egg has cracks in it (they’re still seen as a very positive thing, though they’re not without their own costs and limitations)
  • APIs naturally featured heavily in a few talks as people move more towards service orientation/micro services, and there are now a healthy set of talks on the ‘how do do this part right’
  • Continuous Integration/Continuous Delivery seems to have become less popular/less cool as a topic, but I was able to get some very useful insights on the conference that helped a lot.

You can see the full list of talks I attended here.

My tweet stream for the conference is here, and the full tweet stream for the #BuildStuffLT hashtag is here.

I attended some talks based upon the calibre of the speaker, and in some cases that was a disappointment – I of course won’t mention names, though there were a few of the bigger personalities that disappointed in presentation.

Couple of the talks I took more notes at (in chronology order);

5 Anti-Patterns in Designing APIs – Ali Kheyrollahi (@aliostad)

I loved the visual metaphor presented early in this talk of the public API as an iceberg where the vast majority of the activity is under the surface in either private APIs or business logic, and the public facing element is a small part of it.

The anti-patterns were listed as follows:

  • The transparent server – Exposing far too much information about the internals or the implementation. Having to request resources with your userId in the URL (get-details/12345 instead of /get-details/me) for example.
  • The chauvinist server – Designing the API from the servers perspectives and needs and pushing that thinking and process to any clients if they wish to consume it. Interestingly, Ali came off the fence and suggested HATEOS as an anti-pattern in this regard – I’m not convinced, but it was refreshing to see a strong opinion on this.
  • The demanding client – where certain limitations are enforced from a client perspective (e.g. forcing versioning into the URL as opposed to the headers)
  • The assuming server – where the server assumes knowledge on issues that are inherently client concerns. Good example here was pagination – /get-winners/page=1 versus /get-winners?take=20&skip=0 – we don’t know anything about the form factor on the server, so a ‘page’ has no context.
  • The presumptuous client – a client taking on responsibilities that it cannot fulfil (e.g. client implementing an algorithm that the server should handle, client acting as an authority for caching/authorisation etc.)

Another analogy I liked was in thinking of the API like a restaurant. The front of house is pristine, controlled, serene, structured. How the food arrives at the table is unimportant, and the kitchen (the server side of the API) could be a bed of chaos and activity, so long as the delivery to the front of house is pristine.

Service Discovery and Clustering for .net developers – Ian Cooper (@icooper)

This was listed as .net developers, though in reality the concepts equally applied across other technology stacks but it was nice to see code examples in .net for some of these.

He covered some of the fallacies of distributed computing:

  • The network is reliable
  • Latency is zero
  • Bandwidth is infinite
  • The network is secure
  • Topology doesn’t change
  • There is one administrator
  • Transport cost is zero
  • The network is homogenous

And also covered a number of things around Fault Recovery:

  • Assume a timeout will happen at some point
  • Retry pattern (http status code 429 – ‘Retry-after’)
  • Circuit breaker pattern (another mention for Polly here, which is an awesome library)
  • Introduce redundancy (be careful where state is stored)

Discovery was discussed at length (naturally), and he covered both Server and Client side discovery, as well as the general tooling available to help manage this (Consul, Zookeeper, AirBnB SmartStack, Netflix Eureka, etcd, SKyDNS) and covered the importance of self registration/de-registration of services.

A lot of practical/good content in here and a cracking speaker. Really liked the way he delivered demos via screencast so that he could talk rather than type – I think a lot of speakers could benefit from this approach.

Why Building the Right Thing means Building the Thing Right – Liz Keogh (@lunivore)

A lot of this talk focussed around Cynefin, a framework that seems to have arrived from Dave Snowden and describes a system for understanding and evaluating complex systems as they evolve. This talk covered a number of known concepts to me, but in a new way, so it very much hit upon my ‘must learn more about this’. It covered massively more than I could do justice to (though the link to the talk above from Liz is very similar to the one she presented), and she covered a whole pathway through an organisations agile fluency.

One of two talks at the conference that really gave me ‘take aways’ to go and learn and get better at – so massively happy I attended.

ASP.NET 5 on Docker – Mark Rendle (@markrendle)

This is the first time I’ve seen Mark present and I hope it shan’t be the last. Brilliantly clever bloke, fantastic presentation style, and clearly knows his topic areas well (he gave a closing keynote too which was equally good).

I played with vNext of asp.net in early beta, so it was incredible to see how far it’s come since then. He had brought it all the way up to date (RC1 of the framework had been launched the day before, and he included it in the talk), and the flow and interaction has become really polished.

I have to admit to being behind the curve with regards Docker – understand it conceptually, have kicked up a few docker images, but nothing anywhere near production or usable at any scale. I don’t really have any solid need for it right now, though the talk did demo how easy it was to fire up and deploy the code to a docker container and it’s possibly something to look at once the container/unikernal platform settles down.

All of the demo’s were given on linux/mono, though that evening (tragic I know) I re-worked through the talk on OSX and it all worked a treat so it does indeed seem like Microsoft has the open source/multi-platform delivery message correct here. I’ll do a follow up post on this as it’s now the topic that will take up most of my play time in the evenings.

Continuous Delivery – The Missing Parts – Paul Stack (@stack72)

I talk with Paul at most conferences and have been to his talks in the past, so I hadn’t really thought I’d attend this talk (I’ve heard all he has to say!) – so glad I did. It started after a twitter conversation pre-talk with him and Ryan Tomlinson around where the complexity in micro-services exists (away from the code, and more towards the wiring/infrastructure of it all). Thankfully, Paul’s talk focussed around exactly those topics and it was almost a rant towards the micro-services fandom that is exhibited heavily at conferences currently.

He covered the key tenets of Continuous Delivery:

  • Build only once (never ever build that ‘same’ binary again once you’ve shipped it)
  • Use precisely the same mechanism to deploy to every environment – that doesn’t mean you can use right click, publish to push up to production 😉
  • Smoke test your deployment – this is key – how do you know it works?
  • If anything fails, stop the line! It’s imperative at any stage that you can interject on a deploy that fails

Covered some common misconceptions about continuous delivery:

  • It’s something only startups can do – it’s true that starting in greenfield makes it easier to build upon, but anyone can move towards continuous delivery
  • It’s something that only works for nodeJS, Ruby, Go developers – any ecosystem can be pushed through a continuous delivery pipeline
  • We can hire a consultant to help us implement it – domain knowledge is crucial here, and someone without it cannot come in and help you solve the pain points
  • Continuous delivery is as simple as hooking up github to your TC account – all parts of the pipeline really need to be orchestrated and analysed

There was a really good example of successful continuous delivery and it was a quote from facebook. They deploy new functionality to 17% of the female population of new zealand. Basically, by the time the major metropolitan cities come online, they already know if that feature is working or not.

Some other key takeaways from this talk – you have to ensure you deliver upon the 4 building blocks of DevOps (Culture, Automation, Measurement, and Sharing) in order to ensure you have a strong underpinning. Again, this harks to the micro-services talks – just moving your auth system into a separate service doesn’t give you a micro-service. You need solid infrastructure underpinning it, you need orchestration, you need instrumentation and logging, you need some way of that service being discovered, etc. etc.

Continuous Delivery (to me) feels like a solid building block that needs to be in place and working well in order to act as a feeder for things that micro-services would hinge upon.

He mentioned the Continuous Delivery Maturity Model, and it’s worth everyone reviewing that to see where they sit in each category. One of the key things for my organisation is to review our cycle time and see just what our flow looks like, and if there are any key areas that we can improve upon.

CraftConf 2015 – did someone say microservices?

I’ve just returned (well, I’m sitting on a balcony overlooking the Danube enjoying the sunshine) from two days at CraftConf 2015 and thought I’d share my thoughts on my first attendance to this conference (it’s in it’s second year).  Firstly, lets get the cost aspect out of the way – this conference is incredibly good value for money.  Flights, conference ticket and hotel came to less than the cost of most 2 day conference tickets in London, yet the speaker line up is incredible and the content not diminished because of this economy – if you have difficulty getting business sign off on conferences in the UK, you could do worse than look at this.  That said, a conference is all about the content so lets talk about the talks.

Themes – Microservices, microservices, microservices

Thankfully, more than one person did say that microservices for them was ‘SOA done properly’ – the talks I gravitated toward tended to be around scaling, performance, cloud, automation and telemetry, and each of these naturally seemed to incorporate elements of microservice discussion.  Difficult to escape, though I guess based on the number of people who haven’t yet adopted a ‘small, single purpose services within defined bounding contexts’ (ourselves included) in the room, it was a topic ripe for the picking.


I won’t cover all of the talks as there was a lot of ground covered over the two days – thankfully they were all recorded so will be available to stream from the ustream site (go give the craft conf link above) once they’re all put together.

That said, there were some that stood out for me:

Building Reliable Distributed Data Systems

Jeremy Edberg (Netflix, @jedberg)

I’m a long time fan of netflix’s technology blog, so seeing them give a talk was awesome. I think this one sat up there as one of the best of the conference for me. A number of key points from the talk:

  • Risk in distributed systems – often on releasing teams look at risk to their own systems, risks in terms of time of day, but often overlooked is the risk to the overall ecosystem – our dependencies are often not insignificant and awareness of these is key in effective releasing
  • A lot of patterns were discussed – bulkheading, backpressure, circuit breakers, and caching strategies that I really must read more around.
  • Queuing – the approach of queuing anything you’re writing to a datastore was discussed – you can monitor queue length and gain far better insight into your systems activity.
  • Automate ‘all the things’ – from configuration and application startup, code deployment and system deployent – making it easy and quick to get a repeatable system up and running quickly is key.
  • ‘Build for 3’ – when building and thinking about scale, always build with 3 in mind – a lot of the problems that come from having 3 systems co-ordinate and interact well continue on and are applicable once you scale up.  Building for 2 doesn’t pose the same problems and so bypasses a number of the difficult points you’ll cover when trying to co-ordinate between 3 (or more).
  • Monitoring – an interesting sound byte, though alert on failure, not the absence of success.  I think in our current systems at work we’re mostly good at this and follow the pattern, though we can, as always, do better.

Everything will break!

Deserving of it’s own section as this really has to be handed to netflix as an incredible way of validating their systems in live.  They have a suite of tools called the simian army which are purposely designed to introduce problems into their live systems.  The mantra is ‘You don’t know your ready unless you break it yourself, intentionally and repeatedly’ – they have a number of different monkeys within this suite, and some of them are run more regularly than others, but this is an astonishing way of ensuring that all of your services in a distributed architecture are designed around not being a single point of failure, or not handling things like transient faulting well. 

It is seen as an acceptable operational risk (and indeed he confirmed they had) to take out customer affecting live services if the end goal is to improve those services and add more resilience and tolerance to them.  Amazing!

Incident Reviews

Their approach to these fitted well with what I’d hope to achieve so thought I’d cover them:

It was all about asking the key questions (of humans):

  • What went wrong?
  • How could we have detected it sooner?
  • How could we have prevented it?
  • How can we prevent this class of problem in the future?
  • How can we improve our behaviour?

Really does fit in with the ‘blameless postmortem’ well.

The New Software Development Game: Containers, microservices, and contract tests

Mary Poppendieck (poppendieck llc, @mpoppendieck)

A lot of interesting discussion in this keynote on day two, but some key points were around the interactions between dev and ops and the differing personality types between them.  The personality types were broadly broken down into two: Safety focussed and promotion focussed.  The best approach is the harness both personalities within a team, and ensure that they interact.

Safety focussed

These people are about failure prevention – asking ‘is it safe?’ and if not, what is the safest way that we can deliver this?  Motivated by duty and obligation.  They find that setbacks cause them to redouble their efforts whereas praise causes a ‘leave it all alone’ approach.

Promotion focussed

‘All the things!’ – all about creating gains in the ‘lets do it’ mindset. They will likely explore more options (including those new and untested).  Setbacks cause them to become disheartened whereas praise focuses them and drives them.

As a ‘promotion focussed’ person primarily, I’ve oft looked over the fence at the safety focussed and lamented – though really I think understanding that our goals are the same but our approaches different is something I could learn from here.

From monolith to microservices – lessons from google and ebay

Randy Shoup (consulting cto, @randyshoup)

Some interesting content in this one – his discussion around the various large providers and their approaches:


  • 5th complete rewrite
  • monolith perl -> monolith c++ -> java –> microservices


  • 3rd generation today
  • monolithic rails -> js / rails / scala –> microservices


  • Nth generation today
  • monolithic c++ -> java / scala –> microservices

All of these have moved from the monolithic application over to smaller, bounded context services that are independently deployable and managed.

He was one of the first (though not the last) to clarify that the ‘microservices’ buzzword was, for him, ‘SOA done properly’.  I get that microservices has it’s own set of connotations and implications, though I think it’s heartening to hear this as it’s a view I’ve held for a while now and it seems others see it the same way.

Some anti-patterns were covered as well.

  • The ‘mega service’
    • overall area of responsibility is difficult to reason about change
    • leads to more upstream/downstream dependencies
  • Shared persistence
    • breaks encapsulation, encourages backdoor interface violations
    • unhealthy and near invisible coupling of services
    • this was the initial eBay SOA effort (bad)
  • “Leaky abstraction” service
    • Interface reflects providers model of the interaction, not the consumers model
    • consumers model is more aligned with the domain.  Simpler, more abstract
    • leaking providers model in the interface constrains evolution of the implementation

Consensus is everything

Camille Fournier (Rent the runway, @skamille)

Not a lot to say about this one as we’re still in the process of looking at our service breakout and on the first steps of that journey, though I’ve spoken to people in the past around consensus systems and it’s clearly an area I need to look into.

Some key comparisons between zookeeper and etcd, though as Camille highlighted, she hadn’t had enough time with Consul to really do an effective comparison with that too.  Certainly something for our radar.

Key takeaway (and I guess a natural one based on consensus algorithms and quorum) was odd numbers rule – go from 3 to 5, not to 4 or you risk locking in your consensus.


A great and very valuable conference – discussion with peers added a whole host of value to the proceedings and to see someone using terraform tear down and bring up a whole region of machines (albeit small) in seconds was astounding and certainly something I’ll take away with me as we start our journey at work into the cloud.

A lot of the content for me was a repetition of things I was already looking at or already aware of, though it certainly helped solidify in me that our approach and goals were the correct ones.  I shall definitely be recommending that one of my colleagues attend next year.

Ryan Tomlinson : ITeamLead, ISolutionsArchitect, IPassionateDeveloper

I thought I’d write up a post about a member of my team, Ryan Tomlinson.  I’ve had the pleasure to work with him for the past 2 years, when he joined our employer as a senior software developer.  Very quickly he joined the projects team and after a period working on other projects took up lead on the implementation of our Spanish website.  It was here that Ryan really started to show the skill set that he had, and he helped bring into tombola an awful lot of the project management practices and software architecture that are very actively followed today.  When I was awarded the web team lead role it was only a gnats hairs breadth between us on which would have been best for the role, and in all honesty we both were ‘best’ for the role, just different.  He has since gone on to work on, and lead, multiple projects at tombola, always bringing his ‘best practice’ approach to each.

I’ve never written up a post about another developer I’ve worked with previously, though as Ryan now moves on to a team lead role at TopTable, I felt compelled to write this one.

We have spent the past two years with a relationship bordering on occasional violence because of the insults that we aim at each other, though fundamentally both know it is only achievable with the absolute upmost respect for the other – sarcasm has been a solid comedy mechanism between us, and I shall sorely miss it.

We have challenged each other during his time here on an almost daily basis, and both have grown better as developers, architects, and leads because of it.

He is without hesitation one of the best developers I have ever had the pleasure to work with – his insight, his motivation, his drive, and his experience has brought a massive amount of value to tombola over the past two years, and TopTable have gained an overwhelmingly solid team lead.

Really sorry to see you go mate.

You can see more at Ryan’s blog, twitter, and github

We’re hiring, and we quite like .net developers

I normally wouldn’t use my blog for this sort of thing, though we don’t really have an outlet on our corporate site, so this is the easiest place to do it.  I quite like working at my employer, so thought I’d use this as one of the channels to get the job advertised – I’ve tweeted about it too, please RT if you see it!

We’re hiring, and unlike expensify, we do really quite like .net developers.  We do our best to ‘do good things’, and although we don’t pass the joel test, a score of roughly 7ish with an aim to improve upon our build automation/daily builds/continuous deployment means that I personally find it a good place to work and learn a lot.  There is a team here who care about the work they undertake, they try to learn from one another, and they do their best to leave the code base in a better state than when they found it…

We like to attend UK Developer community events (@NEBytes, @DeveloperDay, @scottishdevs, etc.) and try to better ourselves in any way we can find.

Who are we?

We’re an online bingo company based in Sunderland, though I wouldn’t let any of that put you off Winking smile  Bingo isn’t my life, though as with any business, you can love the job without having to love the subject matter…

There’s a decent sized team here – 8 .net devs (2 ‘game’ guys, 6 web app), infrastructure team (5), flash/client team (5), and a creative team (4) all contribute so it’s a pretty good place to bounce ideas.

We’re re-architecting the current site (MVC3 front end, business/data access tier, DI/IoC, Linq, distributed caching) and that will be going live fairly soon. 

We’re moving into Europe with similar technology and this role would focus on the delivery of that.

The job spec – verbatim

Job Summary

In order to support the growing business, new developers will be required to work on projects building all new website applications for the UK and future European businesses.

Job Responsibilities & Tasks:

A technical specialist within the tombola Operations team, focusing on providing:

  • Website application development.
  • Backend application development.
  • SQL development.
  • Problem and Incident management.
  • Support and maintenance of existing software
  • Keep abreast of industry developments in the technical arena and make recommendations to management where appropriate.


  • Website application development.
  • Developing applications for Windows based systems and Web Applications using IIS 7+.
  • Developing applications accessing an SQL Server backend.
  • Object Oriented programming and design.
  • Visual Studio


  • C#
  • TSQL
  • ASP.NET MVC 3 / 2
  • JavaScript / jQuery
  • Ajax
  • LINQ
  • Internationalisation of .net apps
  • Continuous Integration / Build Management
  • Understanding of theory and application of design patterns


  • Must be passionate about their chosen career path, you’ll be working with people that love what they do – you should too.
  • Must have strong team working and communication skills as well as being confident in working alone.
  • Must be able to work well under pressure, and meet deadlines.
  • Must be highly motivated.
  • Must have good time management skills and be able to multi-task.

Details, details?

We’re looking for 2 people, and salary range will very much depend upon skillset but realistically we’re looking at £30-35k.


Please get in touch with me initially on twitter and I’ll give you corporate email addresses to find out more.

DDD9 – or 10 hours in a car and lots of learning

This weekend saw myself and a few of the developers from work take the long drive down from the relative comfort of the north east down to that there Reading for a day full of community driven talks about our craft.  I won’t give you any real background on DDD9 as @philpursglove has a cracking post on this here.

The sessions I attended were as follows:

.Net Collections Deep Dive

Gary Short (@GaryShort)

Having not seen Gary present before, this talk came as a fantastic start to the day – his presentation style is superb, and the content was perfect for me.

He covered the different collection types, and I got an awful lot from the flow of the talk on which collection types to use in different situations.

Key takeaways for me on this one were:

  • the performance aspects of growing collections (the doubling of the arrays, and more problematically the CopyTo that goes on to enable that growing).
  • if you know the size of a collection before you initialise it, specify it (IList<Stuff> stuff = new List<Stuff>(12))
  • Prefer .AddRange() to looping through a collection and using .Add().

He covered a lot more in this talk (sorting algorithms and when to consider using your own sort etc.) but all in all, cracking start to the day.

CQRS – Fad or Future

Ian Cooper (@ICooper)

I arrived at this talk having seen Ian present before on different subjects so knowing he was good, and having utter cynicism on CQRS (Command Query Responsibility Segregation).  It seemed to me (note the past tense) like an utter waste of time and something that allowed/supported a weaker architecture.  Very much a toy for the cool kids.

Well, the talk has convinced me that I need to look into this as a lot of what Ian said resonated with me.  Having a thin ‘read’ layer that (in our case) would return our View Models completely away from the domain objects makes so much sense – do I really need a 7 table join ‘User’ object *just* to present the pertinent details to the user allowing them to change their password (caching in place or no!).

The domain object would get involved on the commands – the changing of something, and at this point the domain model is a godsend naturally as it validates whether or not what you are doing is valid.

I like that it simplifies down our Service and Repository layers, and can see some real potential from it all.

It’s not something I’m going to rush out and implement tomorrow, but it’s something that has now hit the reading list as something that I must understand with an aim to be better informed when I make architectural design decisions in our software – I will no longer rule it out as a fad that’s for sure.

Functional Alchemy – how to keep your c# code DRY

Mark Rendle (@markrendle)

This guy was a great speaker – fantastic talk, his knowledge of the functional aspects introduced to the .net framework was huge, and he certainly used them well in his examples.

What this talk highlighted is just how shit I am!  There are aspects of the .net framework that I have very little understanding of (am I supposed to admit this publicly? lol).  I use and consume Func<T> and Action<T, TResult> on a day to day basis on the framework with no problem (and love them).  Does not knowing how to ‘roll my own’ affect my day to day job? Not really.  Do I want to know them to add to my toolbelt?  Damn sure.  Some of the stuff he was doing with (in his own words) abuse of Actions and Functions was incredible.  There are some really nice patterns that come out of this, and it’s linked for me to the Monads talk that Mike Hadlow gave as things I ‘Must try harder’ at.

I suck Smile

Is your code SOLID?

Nathyn Gloyn (@nathyngloyn)

Very good talk covering the origins and usages of SOLID, including code samples that demonstrated it.

I would encourage anyone that doesn’t understand these principles to read up on them (a google search will reveal much), they very much apply to all software development and even a high level understanding of them *will* make you a better software developer.  They’re not all prescriptive, they are tools to use as and when you feel it applicable, but having them in your mind while you design software is gold dust.

Thankfully the talk for me helped solidify the approaches we are taking at my current employer are the ‘right’ ones, and it was a ‘warm blanket’ type talk that made me feel like I wasn’t an utter numpty.

CSS is code, how do we avoid the usual code problems?

Helen Emerson (@helephant)

I felt like a lone sheep during this one, as I use (and really like) reset.css files (though I understand why Helen doesn’t), I thankfully work in an environment where backward compatibility means that if it doesn’t have rounded corners in IE6 but it ‘works’ then jobs a good un, so I very much felt Helen’s pain when she explained some of the hoops she has to jump through to ensure cross browser remains as similar as possible.

Although a good talk, the key gain from this talk for me was at the end when the community chipped in.  So for example there’s the following products/projects I need to look at:

  • dotLess/SASS – means of treating CSS as a programming language with variables/mixins etc.
  • Selenium, Browserlabs and Mogotest as means of testing UIs

What I did also get from this was Helen’s blog which I’ve subscribed to – she has a lot of very good stuff to say and I’d recommend folks that have any interest in front end have a read of it.

Beginners Guide to Continuous Integration

Paul Stack (@stack72)

This guy has been helping me a lot over Christmas with setting up our CI build, so was nice to finally meet him and say hello (surprising how many people just recognised me yesterday – who’d have thought that I stand out at 6’ 9”! Lol).

He didn’t really cover anything new for me, though really again helped solidify that continuous integration is the ‘Right Thing’ to do.

Most importantly from this talk (and the conversations I had with him over Christmas) – do it in small steps – don’t try to achieve everything straight off.  Set it up, get it checking out and building first – light stays green?  Do a run through of unit tests next.  Light stays green? Look at code coverage and other tasks.  Light stays green? Deployment… etc. etc. etc.

This way, over time you’ll build up the build that you *want* without all that significant up front cost.


Another brilliant day run by the community, for the community, and I can only thank all the organisers and speakers for taking the time out to organise it, along with a huge thanks to Microsoft for the venue – the cookies were ace!

Loads of learning points for me, but that’s a huge positive, not a negative!

It was incredible to see on one of the first slides of the day that the North East is getting a DDD event in the Autumn – yay, I can do the geek dinners, the beers, and still get home to a comfy bed!

Roll on DDD Scotland!

2010 – A year in geek

I’ve found it incredibly cathartic to read a few others’ blog posts summarising not only the year that has gone, but their aims for the year ahead – this has been an incredibly busy year for me in geek terms, and I thought I’d write it up, as another hopefully cathartic exercise.

The year starts…

2010 started for me after only four months in a new job after escaping an agency environment in August last year – I honestly didn’t know how badly I had it in my previous role until I started in my current – I took quite a hefty pay cut to switch jobs, but the previous role (I should really say roles, as I was stupidly doing the IT Manager and Dev team lead roles) had me in the last 6 months of it working comfortably 60 hour weeks – I was knackered, home life was suffering, I couldn’t switch off, I was stressed (and anyone who knows me knows I just don’t do stress).

My current role is pretty much idyllic for me – job description is Senior Developer, but we all know that hides a multitude of sins.  Basically, I get to specify technical direction, I get to do staff mentoring/staff support, I get to be involved in the community, but (best of all) I get to spend about 75% of my usable time developing.  Pig in shit I believe is the term they use Winking smile

Legacy Code

Oddly, the first real achievement this year involved minor improvements to our payment system (based upon  legacy code – classic asp – ewww!)  I write it here not because I’m proud of the technology, but of the analytical approach we took, the change process we had in place for the little and often changes to it, and the overall effect of those changes – conservative estimates by our financial officer put us at just over 1% extra turnover.  Now that doesn’t sound a lot, until you see how much the company turns over – needless to say, they were very happy with the work!

Site Rewrite

This has been the big focus for me from around April, and it’s been huge – our existing site is a mix of a lot of classic ASP with a number of .net projects dotted around – the technical debt in there is huge and changes, be it new functionality or modifications to existing functionality are just incredibly costly.  The aim (and I’ve read any number of posts that say this is a bad idea) was to re-write the whole thing into something that was:

a) more maintainable

b) easier to deploy

c) of a far higher overall quality

d) minimised technical debt

e) easier to extend

With that in mind, the technologies that myself and the team have worked on this year have been wide ranging.


The move away from web forms and into MVC has been a revelation.  I lament now the occasional need to maintain our legacy code as once you grok the separation of concerns involved in MVC2 (I heartily recommend both the Steve Sanderson book and the TekPub video series as learning resources). moving back to web forms (especially legacy) is a mare.  I’d say out of all the things covered this year, this is the biggest ‘win’ for me – I can see me using this pattern (and asp.net mvc) for a long time to come as my primary means of delivery over the web.

Testing Software (Unit, Integration, n’all that jazz)

I daren’t call this test driven development as we tend to write our tests after we’ve got the functionality in place – our specifications and business rules in most areas of the rewrite haven’t carried over verbatim, so writing unit tests ahead of time was rarely practicable.  That said, the project is now up to 290+ unit/integration tests, and I suspect before launch that number will nearly double.

It’s very easy during code reviews for team members to validate the logic, outcomes and goals in the unit tests up front so that they form almost a code contract which then goes on to define behaviour and functionality within the code.  It also (assuming business knowledge of the area under test) allows people to highlight potential missing tests or modifications to existing tests.

Learning wise, blogs have been the most use during the year for unit testing, though I would say a must purchase is ‘The Art of Unit Testing’ by Roy Osherove.  It got me thinking about unit testing in a very different way and has led (I hope) to me simplifying unit tests but writing more of them, using mocking frameworks to deliver mocks/doubles, and generally being a big advocate of testing.

Design Patterns

Obviously MVC goes without saying, though this year has seen me read a lot around software design and the patterns used therein.  I feel I now have a solid handle on a great deal more software design from an implementation point of view (the theory was never really that difficult, but turning that into an implementation…).  We’ve used the Service pattern extensively, Repository, I’d like to think we’ve used Unit of Work in a few places, the Factory pattern.  They’ve all seen the light of day (necessarily so) in this project.

There’s a fantastic post by Joel Spolsky about the Duct Tape Programmer which I’d urge everyone to read if they haven’t done so, and it’s about finding that balancing act between software design for software design’s sake (the pure view) versus getting the job done – there’s always a balancing act to be had, and hopefully I’ve stayed on the right line with regards to this.  It’s very easy when focussing on the design of the software to over engineer or over complicate something that should be (and is) a relatively straight forward task.

Uncle Bob must get a mention this year, as his SOLID principles have been a beacon – you don’t always adhere to them, you don’t always agree where they apply, but you can’t deny that as underlying principles of OOD they are a good foundation.

Business Exceptions

Two talks immediately spring to mind when I look at the approach we’ve taken with business exceptions, the first was delivered at DevWeek which I was lucky enough to attend in April (see the post here), the second was delivered by Phil Winstanley (@plip) at DDD Scotland this year.

We’ve very much using exceptions as a means of indicating fail states in methods now, and I love it – coupled with our logging, it feels like we will rarely have unhandled exceptions (and when we do, they are logged), and the overall software quality because of this feels far superior.

I understand the concerns that have been raised around the performance of exceptions (cost to raise etc.) and the desire to not use exceptions for program flow, though I think we’ve struck a happy balance and my testing (albeit rudimentary) earlier in the year suggested to me that the performance of these things was something that just wasn’t a concern.

Continuous Integration

Something that’s been on the back burner for too long now, and only the past week have I made any headway with it, but already it’s a love affair.  I suspect the quality of the information we get out of the system as we move forward will pay dividends, and as we begin to automate deployment/code coverage, and I get more heavily into MSBuild, this is going to be something that I don’t think I’ll want to give up on larger projects.


I now subscribe to approximately 160 blogs, which sounds like a lot, but thankfully not everyone posts as often as @ayende, so jobs a good un with regards to keeping up – I find 5-10mins at the end of the day lets me have a quick scan through those posts that have come in, discount the ones I’m not interested in, skim read the ones I am and star them (google reader stylee) ready for a more thorough read when I get to work the next day.  This may seem a large commitment, but remember I’ve come from a job where approximately 60hrs a week I was ‘working’ (not geeking I hasten to add, just client liaison, product delivery, bug fixing, and sod all innovation)  I now find my working week is down to approx 40hrs work, and between 5 and 15hrs per week on geek stuff depending on the week and what’s on – the extra time I get for self development is just my investment in my career really, and I talk to so many other people on twitter who do exactly the same.


Getting our own local microsoft tech user group (@NEBytes, http://www.nebytes.net) has been fantastic this year – we’ve had some superb speakers, and I know that once a month I get to catch up with some cracking geeks and just talk random tech.  The guys who run it Andrew Westgarth (@apwestgarth), Jon Noble (‘@jonoble), Ben Lee (@bibbleq) and Damian Foggon (@foggonda) do a fantastic job, and I look forward to more of this in 2011.

I managed to attend DevWeek this year, and wrote up a number of things from it, but it was a fantastic week.  Thankfully work saw the benefit so are sending me again in 2011, so hopefully I’ll meet up with folks there and learn as much as I did this year.

Developer Developer Developer days.  These are superb!  Hopefully we can get one organised closer to home in 2011, but the two I attended this year (Scotland and Reading earlier in the year) were packed full of useful stuff, and the organisers need to be praised for them.

Geek Toys – The iPad

I couldn’t round off the year without humbly admitting that I was wrong about the iPad when it launched – I didn’t see the point at all, and was adamant it was going to flop.  Then in October I found myself the owner of one (erm… I actually paid for it too – I have no idea what was going on there!).

Well, revelation doesn’t do it justice – it’s the ultimate geek tool!  Thankfully a lot of the books I buy are available as ebooks also, and I’ve found more and more I’m moving away from print and reading geek books on my ipad – epub format is best (for annotations and the like), though PDF works a treat too.  Aside from that, tweetdeck is a cracking app on the ipad, and it lets me stay in touch with geeks more regularly than I would otherwise have done.  Reeder is my final tool of choice, and the way it represents blogs you’ve not read yet is fantastic.

I’d suggest any geek that loves quick access to their blogs, their books, and tweetdeck (though naturally the ipad does a whole lot more) have a play with one and see if it could be the answer for you too – I’m hooked.

And what of 2011?

Well, I’m over the moon with the way 2010 has gone really – all I can ask is to maintain my geek mojo, my thirst for learning, and a cracking bunch of people to work with and life will be grand Smile

A very quick PS to add a technoarti tag VBXP4MC892BG so that I can claim my blog via them

Windows Phone 7 Launch – c’mon UK providers!

Well, as one of those eagerly waiting when Steve Ballmer launched Windows Phone 7 last week, and then immediately drooling over the devices I can say that my experience from that point on has been abysmal!

I noticed someone from the AUS market posting something similar, and thought I’d quickly relay my experiences within the UK market.

I’m currently an iphone owner with O2, and thought it great that they had the HTC HD7 as a unique offering, the screen size pipped it for me.


Thursday lunchtime I thought ‘right, I’ll see what O2 have to offer if anything’ – 1 week before launch, they’re surely letting people pre-order or telling them how and when they can get one on launch day.  The conversation went:

Me: “Hey there, I’m interesting in upgrading my current package to Windows Phone 7 – have you guys got any information about tarrifs or how I can pick one up next thursday?’

O2: “Windows Phone 7?”

Me: “I know it’s just been launched this week, I’m just trying to get ahead of the game – do you have any details?”

O2: “Do you mean the iphone?”

Me: <blinks>No, surely it already shows I have an iphone – do you not have any information?  The phone is launching through you October 21st.

O2: Ahh, well if you phone us back on that day, we should have more information…

I’m sorry, but what an utterly epic customer team training fail from O2 there – just shockingly bad!

Carphone Warehouse

I’d like to say this was a unique experience, but while out on Saturday (16th – 5 days before launch) I decided to pop into carphone warehouse and ask if they had any info – retailers tend to get to launch info earlier.

Me: “I’m after tariffs and prices for the Windows Phone 7 phones, have you guys had them in yet?”

CPW: “We haven’t heard anything, though we may be getting some test devices in for next weekend”

Me: “The phone launches on Thursday though, will you not have any on launch day?”

CPW: “Ahh, we’re expecting an order later in the week, they might be in there…”

Me: <blinks again>

Closing Plea

This has been an utter fail across the board really – I’m absolutely gutted that such a powerful launch from microsoft last week has turned into the community scrabbling around for any tidbits of information.  It turns out that Orange has one of the phones on their site now with pricing, but as of the time of this post (Monday 18th 9:15am) the pertinent websites stand as follows:

Microsoft: as per launch day, listing the devices and which networks they are available under

O2: the holding page telling us it’s coming – you can sign up for information, and I got an email from them a day later telling me that they’d send me information when they had it #fail

Orange: I’ve misplaced the page where they list prices/contracts, though the fact that stuff is hard to find is still a #fail

Three: There is a pre-register page, and they’ve actually promoted it on their homepage (albeit one scroll down).  With no more information about tariff’s or contracts. #fail

t-mobile: I can find no reference to it on their search page. #fail [edit: thanks to the guys over at bitterwallet, someone has updated with a t-mobile link]

carphone warehouse: again, a search reveals nowt, and there’s nothing obvious via the navigation.

Microsoft – something in the co-ordination of this launch with the suppliers/carriers is fundamentally flawed.  The community heard about the iphone weeks in advance, they knew pricing, they knew how to pick one up on launch day.  The day of the launch, it was nice that the windows phone 7 site was pointing at the providers websites so that you could go ‘direct’ to the source of the details… only to be given a 404 not found error on every one of them – I mean FFS!

It seems that Windows Phone 7 is the big secret that nobody wants to let out – and yes, I wouldn’t be surprised if I walked into a shop on thursday and they had them, but really, that’s not the point – you have a community of people clammering for your new OS and these new devices, and nobody is telling us anything.  Yes, like the rest of us waiting I’ll sit tight and wait, but this really should have been addressed long before Steve Ballmer opened his mouth on that launch day…

Google Instant Search – is this a bug?

I got the news through about google instant, and started playing straight away – I’m really liking it, and although people on the team find the search results slightly ‘jarring’ when they change, I love it.

Interestingly, I work for an online bingo retailer (tombola), and we were really quite proud last week to hit 4th when searching for ‘bingo’.  From everything we’ve heard, google instant doesn’t make a blind bit of difference to the search, so “great” thinks I – though I’ll run a few tests just in case.

Appending to a search

  1. Using instant, type ‘bingo’ as your search – you should see tombola come up 4th (as of the time of this writing).
  2. Add a space as if you’re about to change the search – google instant correctly changes the search and different results are generated (we drop off the first page).
  3. Remove the space (you changed your mind didn’t you, you really wanted to see us!) – the original results set are returned back to their usual state.

Well done google!

Prepending to a search

I admit, this use case is going to be used far less than the original above, but ‘bingo’ is one of those words – it can happen at the start or at the end of a search term.


  1. Using instant, type ‘bingo’ as your search – you should see us come up 4th again.
  2. Click to the start of the search, and put a space in – the results change, and we drop off the page, and Gala Bingo comes out as the primary search.
  3. Remove the space…

Hold on, where did we go? The results haven’t changed? But my ‘search intention’ has changed!

Is it a bug?

Well, that remains to be seen.  The above ‘behaviour’ can also be demonstrated by typing ‘development’ and pre-pending versus appending.  Oddly, not all terms behave like this though, so it’s not consistent.


Chrome – are you sanitising my inputs without my permission?

I had to write this as I’m going mad, and I can’t really work out if it’s me, or if Chrome is indeed utterly fecking with my inputs.

I’m creating a form that takes (as a hidden variable) a string like this:


Double pipes at start and end are put there by me to denote where the carriage returns occur.  In particular, you can see there is a carriage return after the last character.

Browsers that work

When I render this out in a hidden field in firefox (or indeed any browser other than chrome), I get the following when viewing source:

<input name="PaReq" type="hidden" value="eJxdUt1ugjAUvvcpml1tN5QiKpraROeSmQxnNl+gKyfKJgVLGbqnX4tW0CYk/X5oT79z6GanABaf

" />

Notice in particular that the form field ends with the correct carriage returns.

When posting this to the third party provider (this is a 3D Secure transaction, letters have been changed to protect the wealthy!), jobs a good un, works no problem at all.

What happens in Chrome

When I view the same source in Google Chrome (5.0.375.99), I get the following:

<input name="PaReq" type="hidden" value="eJxdUl1vwiAUffdXkD1tLwVq/QyS1Pkwk9WZzT/A6I02U6qUrrpfP6hiW0mb3HPPAS7nXrbZaYDF

Erm… Chrome – where did you put those carriage returns?

I’ve tried deliberately placing carriage returns on the hidden field, adding them to the variable, etc. and still, it removes them.

It’s almost like the value has had a .Trim() applied before being output?

This transaction fails (oddly enough, invalid paReq), and although I can’t prove it, my guess is that the carriage returns are significant in this.


Am I going mad here?  Am I missing something obvious?  Is this a bug or indeed a feature?


This has now been confirmed by a few people – terrifying though that is. If whitespace is important to your form inputs (well, trailing whitespace), then the cry is ‘be careful!’.

Someone suggested a workaround on stackoverflow (http://stackoverflow.com/questions/3246351/bug-in-chrome-or-stupidity-in-user-sanitising-inputs-on-forms) which works a treat, and out of all solutions I can think of, is the most elegant.

Thanks for the feedback from all – it’s been a really useful exercise!