Dan's Development Blog

Rhino Mocks Stub Ref Parameter

dan — Fri, 10 May 2013 23:48:00 +1000

A quick tip here, we've just spent what felt like ages trying to Stub a method with a ref parameter using RhinoMocks, you'll also need NUnit for the code below to work.

The problem we had was for the .Ref() method we needed an AbstractContraint but the normal Is.Anything didn't work, but if you use: Rhino.Mocks.Constraints.Is.Anything() it works fine.

RhinoMocks Stub with a Ref Parameter Example

using NUnit.Framework;
using Rhino.Mocks;

namespace RhinoRef
{
	[TestFixture]
    public class RhinoMockRefTests
    {
		[Test]
		public void Should_be_able_to_stub_a_ref_parameter_in_rhino_mocks()
		{
			var repo = MockRepository.GenerateStub();

			repo.Stub(r => r.Get(Arg.Is.Anything, ref Arg.Ref(Rhino.Mocks.Constraints.Is.Anything(), 0).Dummy))
				.Return("StubQuestion");

			int theAnswer = 42;
			var theQuestion = repo.Get("anything", ref theAnswer);
			Assert.That(theQuestion,Is.EqualTo("StubQuestion"));
		}
    }

	public interface IGetThingsOutOfTheDatabase
	{
		string Get(string name, ref int awkwardParameter);
	}
}

DIP - The Dependency Inversion Principle

dan — Mon, 06 May 2013 00:54:00 +1000

Here it is the final SOLID principle the Dependency Inversion Principle. In this brief video we'll talk about Robert Martin's premise that:

A. High-level modules should not depend on low-level modules. Both should depend on abstractions.
B. Abstractions should not depend upon details. Details should depend upon abstractions.

Shoutout

The opening drawing of 'inverted dependents' was originally by Tim Musgrove, it made me laugh, full credit to him for that :)

SOLID Principles

The SOLID principles are namely.

I will measure this by

dan — Fri, 03 May 2013 06:22:00 +1000

As a [role], I want [requirement] So that [reason], this particular arrangement of words will be familiar to any agile team. Our board is littered with cards in this format. We tend to then have acceptance criteria in the BDD style of given when then. We sometimes differentiate and have Epics for the higher level stories but it's all very familiar.

In the last few companies I've worked we've been increasingly talking about the "the measure of success", initially this was a notion and merely stated vaguely, this should improve conversion rates. Or improve the customer experience. Or everyone's favourite improve revenue. But this was the so that the reason for the story. In some cases we would have 2 so that's. The first was for the websites visitor So that i can buy music and then we'd have a second so that the company can increase its revenue. Thus linking it back to the businesses driver. I liked this small addition, because it helped us keep sight of the underlying business value that we were trying to deliver.

Build measure learn

One book that had heavily influenced my thinking of late has been The Lean Startup by Eric Ries the build measure learn cycle just makes a lot of sense.

I think there's s disconnect between the user stories we write, features we build and what we measure. In the lean startup they talk about validating features.A story has to go live to be validated but we don't have this on our board. Your definition of done is in production, feature delivered, but does that go far enough?

A new feature isn't an instant hit, we provide an API when we deploy a new endpoint it takes time for partners to integrate with it. Simple things like counters can throw some much needed light and give us a good indication of how many partners are using the new endpoint as our measure of success.

I will measure this by

The important thing about measuring success is that you need generally to measure an improvement so if you aren't measuring this thing in the first place you need to get some metrics in as a basis for comparison. It also starts you thinking about what are they key metrics for your company and what are the key metrics for your team and how do they relate to the company KPIs then going forward how does a story feedback into those metrics?

Therefore I'd like to propose an addition to the user story format, namely I will measure this by. This encourages us to ask how are we going to know whether we've truly delivered the business value, which the so that implies, if it's revenue then put a counter on for revenue from PayPal in the below example. You will then be able to confidentally say you've added business value. The card mentions comparing this against overall revenue and we're concerned with overall revenue increasing so it's entirely possible that PayPal won't increase overall revenue but just take away from the other credit card method. But we should see this because we define it in out I will measure this by.

As a <role>
I want <requirement>
So that <value>
And I will measure this by <measure of success>

Thanks and please try writing a story in this format and see how it goes.

What the Customer Cares about

dan — Tue, 23 Apr 2013 07:04:00 +1000

Do you know what your customers care about? Recently I've been conducting short 30 minute interviews with various internal customers to try and learn a bit more about what they care about, what they worry about, their aspirations for the future and frustrations with the present. It's been quite enlightening and has yielded both great ideas worth persuing and humbling truths worth hearing.

Strangely in software development we seem to be insulated from our customers. Our project might be about "boosting revenue" or "improving efficiency" but that's often all we know. We'll have received this mission from a product owner who might be a proxy for the real departmental customer, if we're really lucky we'll have a real person from the actual department we're doing a piece of work for.

So let me ask a question, how much do you know about your customers? What does their team care about, who are their customers and what teams do they most often interact with. Book a quick meeting in with them, for an informal chat, I simply sent an informat email saying that I'd like to learn more about their team and would they mind if I interviewed them briefly. I attached the questions I was likely to ask (see below) and if they were up for it I'd book a meeting.

Here's my rough format, I'll send an email entitled:

A quick interview to help YOUR TEAM understand a little more about CUSTOMERS TEAM eg Sales / Marketing.

I'll attach the following questions to give them a heads-up and time to ponder some anwers.

So tell me about CUSTOMERS TEAM.

A nice opener, everyone sees themselves in a unique light. A sales teams might not consider themselves about revenue but about helping their clients deliver fantastic service using your product.

What are the components of CUSTOMERS TEAM at YOUR COMPANY, sub-teams, areas.

Do you know how your customers team is organised? Are they split by country or function. For example if it's marketing is there an SEO team and a Social Media team? Does copyrighting come under SEO or are they something different. Do they have teams around your companies different brands? Is the brand team under marketing or are they separate again?

Who are your customers / stakeholders

Who are your customers, customers? It is always good to see who your customer is trying to keep happy. Do copyrighting interact with legal a lot or is the SEO team the more important stakeholder in new articles written, the more you can understand your customers predicament the more you can write code that keeps their customers happy and hence your customers happy.

What teams do you often interact with, who do you depend on?

Are customer services always working with the web support team over customers having forgotten their password, maybe it's about time you put a 'forgot my password' button on the page. Wouldn't that make everyone's lifes easier.

What are the key measurements you worry about.

Is it revenue for sales? Prehaps churn rate or ARPU for marketing. Operations are likely to care about uptime, but what about Customer Services? Is it number of open queries or the average time to a query being resolved?

What are you measured by, and who measures you.

For sales you can imagine it being revenue related and probably by the CFO or CEO, but prehaps this assumption is wrong. If customer services are measured by the length a customer problem takes to solve and there's a very common problem that's very time consuming to fix, a bit of work from a development team can have a massive effect on their KPI's.

Where do you want to be in 6 months.

Are Customer Services hoping to move off some internal tool and onto some externally hosted CRM platform. What are they hoping this will give them, is there anything you can do to help? Or anything that might go wrong that they're unaware of.

If YOUR TEAM could do one thing for you what would it be.

You're not promising anything but it gives you a really good idea of your customers priorities and what they perceive as the big issues. I've been shocked to find them say it's not the project we're about to start. Apparently that was someone higher ups idea. All they want is a small feature and that'll be more than enough to help them achieve their goals. I've heard feature suggestions that are simply brilliant and not even that hard to implement and walked out thinking why didn't we think of that or why don't we have that feature we must have a 'forgot my password' link surely customers don't have to fill out a contact us form.

If Technology could do one thing for you what would it be.

Same as above but for your department. This is always a good one because it puts what they'd love from you in context with other bits of your department. "What we'd love is if we could let our Phones and Tablets on the internal network so we can test that our microsites look good on mobile devices before we go live". Ok I can talk to the network guys I'm sure they can sort that out in 10 seconds all our team do that for application feature testing anyway I can't see why you can't have the same access. It's amazing what silly little things you didn't think of can be such a big issue to other departments. I've learned we really take the privelege of being able to for example 'install chrome' for granted as developers.

What are you excited about,.

It might be that new CRM system they've been after for months, they might be about to launch their first social media campaign, is there anything you can do to help them, or do you know another team that can. It's all about empathy and letting that inform all those millions of tiny decisions we make every day as we implement a feature or fix a bug.

It seems tragic that in a world where software is everything and building the wrong software is an expensive endevour we do so little to try and empathise with our customers. I think it was Fred George who pointed out that it is the large financial institutions that are quite used to getting programmers and traders working side by side, strangely in most modern 'agile' shops we have layers of people between 'customers' and 'developers'.

So I implore you, go out and interview your customers and get to know what they care about, and don't forget to share your interview notes with the rest of your team and even department it can only help you in producing software that helps achieve what the customer cares about.

What_the_customer_cares_about.pdf (40.84 kb)

ISP - The Interface Segregation Principle

dan — Tue, 23 Apr 2013 04:18:00 +1000

For the penultimate episode of my mini-series on the SOLID Principles we look at the Interface Segregation Principle or ISP which states:

No client should be forced to depend on methods it does not use.

LSP - The Liskov Substitution Principle in 5 minutes

dan — Fri, 05 Apr 2013 19:17:00 +1000

So for the 3rd installment in my mini-series on the SOLID principles we have the Liskov Substitution Principle or LSP. In under 5 minutes we briskly talk about Barbara Liskov and her assertion that:

if S is a subtype of T, then objects of type T may be replaced with objects of type S

What does that mean? well watch the video ;)

Living with Legacy Code Talk

dan — Fri, 22 Mar 2013 20:15:00 +1000

Well it happened, Leon and I actually did our little presentation at the Devs it a Ditch meetup. Naturally there were a few technical difficulties (no sound), which prehaps is for the best, and thankfully resolved by the time the Raspberry Pi talk started (conspiracy theorists say what you will).

Thanks to all involved in the preparation, Darrell, Chris, Paul, Nina, Georgy and the rest of the gang.

here's the screencast, with audio :)

here's the live broadcast, unfortunately without audio, but you get to see (and hear) Romilly talk about making robots with Raspberry Pi's

Thank you for watching :)

RabbitMq with EasyNetQ Tutorial

dan — Thu, 21 Mar 2013 20:59:00 +1000

I've been playing with EasyNetQ recently as a gentle introduction to RabbitMQ. Increasingly we seem to be thinking what our codebase would look like if implementted using message queues. Our hope is that it will make implementing lots of simple systems even easier.

The Video - (the written tutorial is below :)

Before we Begin, be sure you've got RabbitMQ

I've even made a little video on how to install RabbitMQ with the Management Plugin on Windows.

The source code for this tutorial is on GitHub to make life easier :)

You'll also need Visual Studio (i'm using vs2012) etc.

The Domain

We're going to be making a very simple ordering system for our fictional company IWantATesla.com in the tradition of all modern web companies we'll be implementing a RESTish API that will receive an HTTP request and then Publish an Order for a Tesla Car. Since demand is likely to be so high we might have to have load balance between various Subscribers who will then be able process the order which might involve considerable work. From the API client perspective, we don't have to wait for all the processing to happen we can have a quick response that just acknowledges the order was received and then we can go about are lives knowing at somepoint soonish we'll probably get a receipt or order confirmation email or something.

Step 1 - New WebApi Project

Create a new Solution (we're gong to need several projects for this). Create a new ASP.NET MVC 4 Web Application

of the WebApi variety for good measure.

Step 2 - Install EasyNetQ

Right easy bit nice and simple

Step 3 - Create a Class Library Project

Ok this might seem stupid, but in order (pun?) to ultimately share a message between our WebApi project which will be our Publisher and a console app (which we'll get to shortly) which will be our subscriber we need to have a common type that both can understand. EasyNetQ in it's opinionated way thinks we need to at a minimum use a .Net type as a message and I'm inclined to agree. So what we're going to do is create a very minimumal Class Library Project called IWantATesla.Messages and then reference from within our WebApi project and then our console app subscriber. This project will have 1 class (I said it was minimal) called TeslaOrder and it looks like this.

namespace IWantATesla.Messages
{
	public class TeslaOrder
	{
		public string CustomerEmail { get; set; }
		public string Model { get; set; }
		public string Color { get; set; }
	}
}

Step 4 - Create a new ApiController

Now back to the WebApi project, firstly reference the IWantATesla.Messages project you just created above. Next we create a new ApiController below is some code. If we create a controller and inherit from ApiController like the below OrderController it'll by default correspond to the path http://localhost:portnumber/api/order where order corresponds to OrderController. In our simple code below we're only going to handle the POST response where we hand back a HttpResponseMessage which is always Created (we hardcoded that in).

using System.Net;
using System.Net.Http;
using System.Web.Http;
using EasyNetQ;
using IWantATesla.Messages;

namespace IWantATesla.WebApi.Controllers
{
	public class OrderController : ApiController
	{
		// POST api/values
		public HttpResponseMessage Post([FromBody] TeslaOrder order)
		{
			var messageBus = RabbitHutch.CreateBus("host=localhost");

			using(var publishChannel = messageBus.OpenPublishChannel())
			{
				publishChannel.Publish(order);
			}
			return Request.CreateResponse(HttpStatusCode.Created);
		}		 
	}
}

But there's some magic EasyNetQ stuff in here to. You'll note we create a RabbitHutch.CreateBus("host=localhost"), just the name rabbit hutch always makes me smile. So it's here that we're connecting to our running RabbitMQ server (please make sure it's up and running), but it's very simple. We realy on WebApi magic to bind the TeslaOrder from the POST request that comes in and then we simply, have a using() statement (the publish channel must be disposed afterwards), and we call messageBus.OpenPublishChannel() what this does is create an Exchange on RabbitMQ called IWantATesla_Messages_TeslaOrder:IWantATesla_Messages and then we call pubishChannel.Publish(order) which sends the message to the RabbitMQ Exchange.

Step 5 - Create a Console App Project called OrderProccessor

Yes I'm afraid we need another project. As above you'll need to use Nuget to reference EasyNetQ and you'll also want add a project reference to IWantATesla.Messages. Once you've done that we're ready to write our rediculously simple subscriber.

Actually we're not going to do the absolute simplest thing we're going to do a little bit more just to make our subscribers output a little less cluttered. Lets start with the code below:

using System;
using EasyNetQ;
using IWantATesla.Messages;

namespace OrderProcessor
{
	class Program
	{
		static void Main(string[] args)
		{
		    var logger = new LogNothingLogger();
			var bus = RabbitHutch.CreateBus("host=localhost",reg=>reg.Register<IEasyNetQLogger>(log=>logger));

			bus.Subscribe<TeslaOrder>("my_subscription_id", msg =>
			{
				Console.WriteLine("Processing Order: {0} -- Model: {1} -- Color: {2}",
                    msg.CustomerEmail,
                    msg.Model,
                    msg.Color);				
			});
		}
	}

    public class LogNothingLogger : IEasyNetQLogger
    {
        public void DebugWrite(string format, params object[] args)
        {
        }

        public void InfoWrite(string format, params object[] args)
        {
        }

        public void ErrorWrite(string format, params object[] args)
        {
        }

        public void ErrorWrite(Exception exception)
        {
        }
    }
}

So first off you'll see there's 2 classes here, the first is our Console app called Program and the second is the LogNothingLogger which doesn't do anything as the name and code imply.

If you look at the Program class you can see we construct our empty logging class and call if logger. We then as with the Publish WebApi above create a RabbitHutch.CreateBus only this time in addition to the connection string to our locally running RabbitMQ instance we pass in lambda that says we want to Register<IEasyNetQLogger>(log=>logger) which just says that we want to use our LogNothingLogger class for logging instead of the default one. The default one writes lots of debugging output to the stdout which of course is the same as what our subscriber console app will write to so to mimimise confusion we override it doing nothing and have a nice clean subscriber console output.

So moving on, you can se we call bus.Subscribe<TeslaOrder>("my_subscription_id", Action<TeslaOrder>) where my_subscription_id gets appended to the name of a queue so if we look at the Queues in RabbitMQ you'll see a queue called IWantATesla_Messages_TeslaOrder:IWantATesla_Messages_my_subscription_id. For the Action<TeslaOrder> you'll see another lambda where we expect to be given a TeslaOrder and then we simply Console.WriteLine it out to the stdout. That's it for the subscriber now lets see if it all works.

Step 6 - Multiple Startup Project

Just to make this easy if you right click on the solution and do properties you'll get the below dialog. If you change the action of the WebApi project and the OrderProcessor console app both to start you'll get them both fire up at the same time to make things easy.

Then run all the things...

Step 7 - Post an Order

So at this point you should have a WebApi app up and running (though without having implented GET it's hard to know. Install a plugin like Dev HTTP Client to give your endpoint a poke.

you should also have an empty console app sitting there to. Ok lets give that endpoint a prod. We're going to use a Form Post like below.

make sure you set it to POST and set the Content-Type to application/x-www-form-urlencoded you should of-course probably prefer json or xml but just to keep things simple.

Notice the C# code always returns created even though it doesn't do anything, but if you were to write something else you'd find the WebApi is kindly doing the deserialisation for you.

Not only should you get a 201 Created back but you should also see:

That's it you've done it, you've successfully got a REST service to put messages on a RabbitMQ queue using EasyNetQ which are then processed by separate apps that simply subscribe to the the queue. Fantastic.

Step 8 - Little Bonus of RabbitMQ

Here's a nice little feature of RabbitMQ if you just go to the bin\Debug folder and fire up another instance of the OrderProcessor console app (the subscriber) and then change the color in the Post app and post again, then repeat, you'll start to notice that RabbitMQ automatically round-robins the requests between the subscribers. So in essence free load-balancing which could be very handy especially if you consider how popular Tesla's seem to be (I wonder how long the real queue for a Tesla Model S is).

Conclusion

That's it really, there's a few things I should point out, when we created the bus in the WebApi OrderController we would probably prefer to have it injected in using an IOC container. I believe everytime you do this it creates another connection to RabbitMQ and keeps it open so prehaps a singleton for it. that's all thanks for now and be sure to checkout the EasyNetQ website and GitHub project (the documentations really good) not to mention the RabbitMQ site which is also really good.

Setting up RabbitMq on Windows

dan — Thu, 21 Mar 2013 09:47:00 +1000

I've been playing with EasyNetQ and RabbitMQ recently and I thought I'd make a little precursor video to my EasyNetQ tutorial just to go through setting up RabbitMq on a Windows box. It's really not that hard, the Management console bit is the only bit that some might find annoying. Anywhere here it is:

Thanks again Dan

The Open Closed Principle in 5 minutes.

dan — Mon, 18 Mar 2013 02:48:00 +1000

Following on from the Single Responsibility Principle, we have the second of the SOLID Principle the Open Closed Principle or OCP.

The Open Closed Principle states that classes should be open for extension but closed for modification. It has a long history originally coming for Bertrand Meyer in his book on Object Orientated software construction. In his book he tended to use a base class that base functionality that was then modified by inheritance. Nowadays we tend to use interfaces as the base abstraction so we can completely change behaviour by swapping out any classes implementation.