Search results for 'app:weblogs' matching tag 'Agile'

Mscorlib mocking minus the attribute

Anonymous — Mon, 09 Jul 2012 05:00:00 GMT

Mocking .net framework members (a.k.a. mscorlib) is always a daunting task. It’s the breed of static and final methods and full of surprises. Technically intercepting mscorlib members is completely different from other class libraries. This is the reason it is dealt differently. Generally, I prefer writing a wrapper around an mscorlib member (Ex. File.Delete(“abc.txt”)) and expose it via interface but that is not always an easy task if you already have years old codebase.

While mocking mscorlib members first thing that comes to people’s mind is DateTime.Now. If you Google through, you will find tons of example dealing with just that. May be it’s the most important class that we can’t ignore and I will create an example using JustMock Q2 with the same.

In Q2 2012, we just get rid of the MockClassAtrribute for mocking mscorlib members. JustMock is already attribute free for mocking class libraries. We radically think that vendor specific attributes only makes your code smelly and therefore decided the same for mscorlib.

Now, I want to fake DateTime.Now for the following class:

public class NestedDateTime
{
    public DateTime GetDateTime()
    {
        return DateTime.Now;
    }
}

It is the simplest one that can be. The first thing here is that I tell JustMock “hey we have a DateTime.Now in NestedDateTime class that we want to mock”.

To do so, during the test initialization I write this:

Mock.Replace(() => DateTime.Now).In<NestedDateTime>(x => x.GetDateTime());

I can also define it for all the members in the class, but that’s just a waste of extra watts.

Mock.Replace(() => DateTime.Now).In<NestedDateTime>();

Now question, why should I bother doing it? The answer is that I am not using attribute and with this approach, I can mock any framework members not just File, FileInfo or DateTime. Here to note that we already mock beyond the three but when nested around a complex class, JustMock was not intercepting it correctly. Therefore, we decided to get rid of the attribute altogether fixing the issue.

Finally, I write my test as usual.

[TestMethod]
public void ShouldAssertMockingDateTimeFromNestedClass()
{
    var expected = new DateTime(2000, 1, 1);

    Mock.Arrange(() => DateTime.Now).Returns(expected);

    Assert.Equal(new NestedDateTime().GetDateTime(), expected);
}

That’s it, we are good. Now let me do the same for a random one, let’s say I want mock a member from DriveInfo:

Mock.Replace<DriveInfo[]>(() => DriveInfo.GetDrives()).In<MsCorlibFixture>(x => x.ShouldReturnExpectedDriveWhenMocked());

Moving forward, I write my test:

[TestMethod]
public void ShouldReturnExpectedDriveWhenMocked()
{
    Mock.Arrange(() => DriveInfo.GetDrives()).MustBeCalled();

    DriveInfo.GetDrives();

    Mock.Assert(()=> DriveInfo.GetDrives());
}

Here is one convention; you have to replace the mscorlib member before executing the target method that contains it. Here the call to DriveInfo is within the MsCorlibFixture therefore it should be defined during test initialization or before executing the test method.

Hope this gives you the idea.

Fake a member without worrying about passing the dependency

Anonymous — Thu, 21 Jul 2011 05:00:00 GMT

I have came across this several times in forum (telerik) on how I can really fake an item yet I don’t want to pass the instance as an argument. Ideally, this is not a best design but there are third- partly libraries that you have little control over how its written. Anyway, whatever the case might be. This post will show you how you can achieve the above using JustMock. I will be using MSpec in conjunction for the example.

So here is the sample class that I am going to use:

public class LegacyCode
{
public int CheckUser(string userName, string password)
{
var _service = new LoginService();
return _service.ValidateUser(userName, password);
}
}

Here CheckUser is calling LoginService.ValidateUser that we are going replace with a fake call. Also here is the LoginService class that is not much significant just throws exception when ValidateUser is called that will even confirm if the correct variant is invoked.

public class LoginService
{
public int ValidateUser(string userName, string password)
{
throw new NotImplementedException("Nothing here");
}
}

Here is the specification that I wrote with Justmock and MSpec

[Subject(typeof(LoginService))]
public class when_a_mock_is_called_without_instance_being_injected
{
Establish context = () =>
{
service = new LoginService();
Mock.Arrange(() => service.ValidateUser(userName, password)).MustBeCalled();
};
private Because of = () =>
{
var sut = new LegacyCode();
sut.CheckUser(userName, password);
};
private It must_assert_that_fake_setup_is_invoked_from_context = () =>
Mock.Assert(service);
static LoginService service;
readonly static string userName = "User";
readonly static string password = "Pwd";
}

This concludes that if you have a mock setup and you cant pass the instance via dependency injection, JustMock will still try to find the closest mock setup for arguments that it will replace the original call with when invoked. There is no extra setup call to be associated in that regard and keeps the tool more out of your way.

In addition I am attaching the sample project to let you have a look. Also you will be needing JustMock full edition installed to try this out.

JustMock_Legacy01.zip

Problems and workaround for the EMC Scrum for Team System Process Template

Anonymous — Wed, 04 May 2011 05:00:00 GMT

I have recently been looking at the EMC Scrum for Team Systems (SFTS) 3 Template for TFS 2010 with SharePoint 2010. The core of it works, and works well for Scrum based teams. If you have not used it before have a read of the getting started post to get a feel of what it can do.

However, there are some issues when you try to make use of SharePoint 2010 as opposed to SharePoint 2007. Hopefully you will find some of the adventures I have had enlightening

Installation

The first one is that the installation and configuration tools just ignore SP2010. This means when you try to create a team project using the process template you get the error:

“TF249033: The site template is not available for the locale identifier (LCID).” ”The site template name is: SCRUM.”

You have to manually download and install the SharePoint template WSP, as detail in this blog post. Once the WSP is deployed on your SharePoint 2010 farm you can create new team projects using the process template.

How it looks

There are problems with the way the site renders. The two major issues are the site actions drop down appears behind the main display area (red box in left screen shot), and on some page large blocks of CSS get rendered to the screen as opposed to being dealt with programmatically (right screen shot).

Both of these issues have been reported on the support forum

My reading is that the current SFTS SharePoint template WSP has only had minimal changes to port it to SP2010 from SP2007, just enough to get it to load. I think the key issue here maybe that the SFTS SharePoint template has its own master page. This is something all TFS 2005/2008 templates tended to do, but for 2010 there has been a general move to inherit from core SharePoint master pages. Basically the master page structure needs to be rebuild from the ground up by EMC for fix all the issues, but we can address some of them…

Change the master page

Fixing all the issues in the master page is somewhat daunting as 2007 and 2010 master pages are very different in style. However, after a chat with one of our SharePoint developers it was suggested a better solution is to just tell the site just to use a different master page (one of the SP2010 standard ones). This is a technique we have used on bespoke site upgrades and usually will address most of the issues, then it is a matter of fixing the, hopefully smaller, list of outstanding problems.

So below is the process to make the change

Install SharePoint Designer 2010 on a PC (this is a free download from Microsoft)
Logging in as a user with admin rights on the site, open SP2010 Designer and open the url of the Scrum for Team System SharePoint Site e.g. http://tfsdemo/sites/DefaultCollection/team1
In the site objects tree on the left select the master pages node
You should see four master pages
Right click on the v4.master and select ‘set as custom master page’
Load the site in a browser and it should look like a more normal SP2010 site
You can swap it back by making the SFTS.master the custom master page

Actually on first look the swapping the master page seems to have done the job on the homepage in default view mode without any other edits. However, there are still problem of stray CSS being shown when accessing the other pages, and a trace of green in some of the borders.

So a partial success, but with more work maybe a complete one? But that is not the route I took.

Report Title Click-through

Both the SFTS and standard Microsoft reports are displayed in dashboards the same way, they use a page view webpart and the TFSredirect.aspx page. This shows the report chart and a link to take you to its Reporting Services home when the title is clicked. The rendering of the report works for SFTS, but another reported problem is that when you click the report title links (highlighted in green in above graphic) you get the error

TF250008: This SharePoint site is not currently associated with a team project in Team Foundation Server. To ensure that this site functions correctly, you must configure a team project to refer data for that project to this site. For more information, see this topic on the Microsoft Web site: How to: Add a Team Project Portal. You can use the following querystring argument to specify a specific project: tf:ProjectId.

The error says a workaround is to pass the TF:ProjectID parameter in the title URL. This is the only solution I have found. To do this

Load SQL Management Studio
Open the tfs_defaultcollection DB (or the one for your tema project collection) and the tbl_projects table.
Look for and copy the projectID for the project you want to report on
Open the SharePoint page with the failing chart. Click the small down triangle in the top right of the webpart to get the webpart editor.
In the advanced section add &TF%3aPROJECTID={guid} with your {GUID} to the end of the Title URL (the %3a is the : character)
I also had to remove the &IsDashboard=false else I got a “An attempt was made to set a report parameter 'IsDashboard' that is not defined in this report. (rsUnknownReportParameter)” error.
Press OK to save, the chart should render and the link work

Basically the title URL as automatically build is wrong, it has an extra parameter the report does not support and for some reason the automatically passed project ID is being lost. In fact even when you fix the Url is wrong as the report it points to is a dashboard summary when you probably want to take the user to a fuller version of the report. Which of course you could do by altering the Url provided.

I think the root problem here is that the webpart assumes that the report has a dashboard and full version mode, as many of the MSF agile ones do, so this sort of makes sense.If you reports are single mode you need to pass two Urls.

Again this editing is all a bit of pain, but you don’t do it too often, and you could also write a command line tool to easily get the GUID.

But maybe a better overall option?

However, whilst trying all this I realised that the SFTS created SharePoint site does not really do what much ‘special’. Beyond being a basic SharePoint site it has

a link to the process guidance, but is just an HTML file that redirects to http://www.scrumforteamsystem.com/processguidance/v3/ so can be added as link
a link to the Team Web Access, there is a standard webpart for this or you could just use a link
the front page dashboard, this has the two SFTS chart webparts and a TFS query webpart, but we can recreate this ourselves with the standard TFS webparts

Therefore I would suggest the best option to avoid all these SharePoint 2007/2010 issues is to manually create a new SharePoint site and add similar controls to those used by SFTS to make the SharePoint site you want. As long as you are not creating new team projects all the time this should not be too much of a problem.

The steps to do this are as follows:

In Team Explorer create a new Team Project using STFS template but set it not to create a Sharepoint site (you can always use an existing SFTS Team project if you want in place of this step if it already exist)
On the default collections SharePoint e.g http://tfsdemo/sites/DefaultCollection create a new site (site actions), give it a name e.g. ‘Team1’ so it’s URL is http://tfsdemo/sites/DefaultCollection/team1. You can select any site template, but the collaboration/team one would seem a good start, nice and generic
In Team Explorer select the STFS created in step1 and right click, select team project settings | portal settings
Check the enable tram project portal (if not already set) press the configure URL and enter the details of the site created in step 2, press OK to exit
Check the ‘reports and dashboards refer to data for this team project’ checkbox and press OK.
Return to the web site created in step 2, it is now wired to the correct team project

You can now add pages, links and webpart to the web site to build your portal. The most important are

Adding the set of ‘Visual Studio Team Foundation Server Web Parts’ which provide items such a build list, work item list etc.They should all pickup the correct team project.
The page viewer that allows redirections via the TFSRedirect.aspx page as detailed above

We can also link directly to the reporting services reports using the SQL Server reporting web part. As SFTS does not ship its reports as Excel workbooks we don’t have to consider Excel Services..

And finally

I hope this post has given you some ideas as to how to address the issues with SFTS 3.0 on SP2010, enough too keep you happy until there is a release of the template what fully supports SP2010.

My upcoming speaking engagements for Spring/Summer 2011

Anonymous — Tue, 03 May 2011 05:00:00 GMT

I have a couple of community speaking engagements coming up

Both are free, so if you are in the either area, I would be surprised if you were at both given the locations, I hope you can come along

Mocking constructor

Anonymous — Tue, 22 Mar 2011 05:00:00 GMT

Often we end up in a situation where constructor call on the target type requires us to include a config file in our test project or requires firing up some external process. To better illustrate this if we create an entity framework data container either new or from an existing database , we will likely to end up with an entry point class that requires either a valid connection string to be passed or if we expand the default constructor we might see this:

/// <summary>
/// Initializes a new NorthwindEntities object using the connection string found in the 'NorthwindEntities' section of the application configuration file.
/// </summary>
public NorthwindEntities() : base("name=NorthwindEntities", "NorthwindEntities")
{
this.ContextOptions.LazyLoadingEnabled = true;
OnContextCreated();
}

The comment clearly shows that by default it will search for a connection string named “NorthwindEntities” in the configuration file. Though this is not an ideal case where it makes the class more production oriented less TDD friendly (if you think it in a TDD purist way) but to avoid this kind of situation the newest release of Telerik JustMock (Free / Commercial) includes a way to mock such case comprehensively. Thus making it flexible for testers who don’t need to include a configuration file or initialize a default service.

Using the JustMock free edition, I can now easily make the following test pass with the above constructor:

[TestMethod]
public void ShouldAssertWhenSaveOperationIsExpected()
{
var context = Mock.Create<NorthwindEntities>(Constructor.Mocked);
Mock.Arrange(() => context.SaveChanges(Arg.IsAny<SaveOptions>())).MustBeCalled();
context.SaveChanges(SaveOptions.AcceptAllChangesAfterSave);
Mock.Assert(context);
}

The key here is the Consturctor.Mocked overload in Mock.Create<T>. By default it is NotMocked as general but incase your constructor is throwing some unknown exception and you have little control over its codebase then this could be just it.

# region Developer’s log:

As the feature is supported in JustMock free edition, it is right to say that there is no profiler involved. Therefore, it is not possible to use FormatterServices in that regard :

var context = FormatterServices.GetSafeUninitializedObject(typeof(NorthwindEntities));

If we just open up the NorthwindEntities class in IL dissembler , we will see something like the one shown below:

IL_0000: ldarg.0
IL_0001: ldarg.1
IL_0002: ldstr "NorthwindEntities"
IL_0007: call instance void [System.Data.Entity]System.Data.Objects.ObjectContext::.ctor(string,
string)
IL_000c: nop
IL_000d: nop
IL_000e: ldarg.0
IL_000f: call instance class [System.Data.Entity]System.Data.Objects.ObjectContextOptions [System.Data.Entity]System.Data.Objects.ObjectContext::get_ContextOptions()
IL_0014: ldc.i4.1
IL_0015: callvirt instance void [System.Data.Entity]System.Data.Objects.ObjectContextOptions::set_LazyLoadingEnabled(bool)
IL_001a: nop
IL_001b: nop
IL_001c: ret

Here on line 4 it is first calling the base constructor which is actually the case for all .net objects. Even If the class has no base, .net framework will still do an instance call to System.Object itself. But it is possible to skip the call during proxy initialization which is on the other hand is not possible in C# if the base class has no default constructor. Of course, this wont work with sealed class in that case profiler is the only resort. Also, Silverlight runtime does not allow it but you can still reference Silverlight class library from .net test project and things will work just nicely.

#endregion

Hope that you will find the Constructor.Mocked feature useful. You can download the project for this post here EntityFramework01.zip. Finally If you like NuGet, you can also try install-package JustMock to grab the latest build.

Thanks

Follow up to yesterdays events on ‘enabling agile development with cool tools’

Anonymous — Fri, 28 Jan 2011 06:00:00 GMT

Thanks to everyone who attended yesterdays Black Marble event ‘Enabling agile development with cool tools’, both Gary Short’s and my sessions seemed well received. I was asked if my slides would be available anywhere, well the answer is no. The reason for this is that my session was mostly demo driven, so the slides just set the scene. After a bit of thought, a quick blog post seems a better option; so this post covers the same basic points as the session. If you are interested in any of the products I would urge you to download them and give them a go. Many are free and all have at least a free fully functional evaluation edition.

So the essence of my session was on the project management/administrative side of agile projects. The key here is communication both inside and outside of the immediate project team. How to we capture and distribute information so it assists the project not hampers it?

Traditionally the physical taskboard, with moving moving some form of postcards around has been the answer. This is a great solution as long as the team is co-located and that there is no need for a detailed on going record of the historic state of the tasks (maybe a requirement for legal reasons, but then maybe a daily digital photo would do?). Anyway many teams find they need to capture this information in some electronic form. In my session I looked at some of the options with TFS2010

What is built into TFS2010?

As TFS has a single work item store you can edit work items with a wide variety of clients. In the box you have tools to edit work items via Visual Studio, SharePoint, Team Web Access as well as the ability to manage work items in Excel and Project.

What if I live in Outlook?

If you want to do all you work item management in Outlook then have a look at Ekobit’s TeamCompanion. This in effect allows you to treat work items in a similar manner to email, and cross between the two. So you can create a work item from an email and vice versa; it also allows the managing work items in batches. This product strikes me was very well suited to an email based support desk or project manager that is meeting or email orientated, maybe dealing with people who do not themselves have access to TFS, just email.

How can I replicate my physical taskboard?

For many teams the capture of the physical taskboard information is the key. I have always found a good way to make sure TFS work items are up to date is to have all the work items associated with the tasks on the taskboard returned via a TFS query and then in Excel, as the daily stand up is done, make sure each task is up to date.

However, some people like to work more visually than that, so in the session I looked at a couple of desktop applications that allow work item management both in a form editing manner and via taskboard like drag and drop operations. These were Telerik’s Work Item Manager and EMC’s TFS Work Bench.

However for many companies adding another desktop application to a controlled IT PC can be a problem so I also had a look at Urban Turtle an add-in to Team Web Access that allows a more visual taskboard approach with in a browser by adding a couple of tabs to those in the standard Team Web Access product.

But what about outside the team?

All the products I showed in the first half of the session were in essence work item editors, a team could choose to use any or all of them. This does not however really help with getting information out to interested parties beyond the team; for this we need publically accessible Information Radiators. The information on these needs to change over time and be easy to understand.

The output of the team focused tools may be just what you need here, maybe a chart printed out and stuck to a notice board will do, but there are some other options.

The first is that there are a rich set of reports in TFS, available both as Reporting Services reports and Excel charts. Reporting Services is particularity interesting as it can deliver reports to interested parties on a scheduled e.g. the CTO get the project burn down emailed as a PDF every Monday morning. There is also the option to deliver reports to central information sites such as Intranet SharePoint servers for everyone to see.

But what do you do if you want something a bit more striking, something that does not require a person to look on a web site or open their email? Maybe a big screen showing what is going on in the project? I showed two products to do this one was Telerik’s Project Dashboard and the other a version our Black Marble internal BuildWallboard, written using the TFS API.

So in summary, in my opinion the key differentiator for TFS over ALM solutions built for a set of different vendors products is that there is a single store for all work items so a wide range of editing an reporting tools can be bought to bear without having to worry over whether the information you are working with is the going to be passed correctly between the various components of the system.

So again I would urge you that if you use TFS have a look at these product, and the many others that are out there, given them a go and see which ones may assist your process. Remember agile is all about continuous improved isn’t it, so give it a try

How to raise event for a mocked call.

Anonymous — Wed, 06 Oct 2010 05:00:00 GMT

Recently, while i was working with a support issue , i found this interesting piece of test code that i would like to share here. This is actually written by Stefan Lieser (Out from German .net community forwarded to me by Jan from Telerik Germany). As the title states, it is to mock a specific event for an expected call.

Now Stefan wants to raise an event from WebClient class of System.Net for a download operation. Therefore, first the WebClient class is mocked during setup.

[SetUp]
public void Setup()
{
webClient = Mock.Create<WebClient>();
}

Next the mocking here takes place in two part. First, DownloadDataCompletedEventArgs is mocked to return an expected data when Result property is get.

var e = Mock.Create<DownloadDataCompletedEventArgs>();
var data = new byte[] { 1, 2, 3 };
Mock.Arrange(() => e.Result).Returns(data);

This is followed by an arrange that will raise the expected event when DownloadDataAsync is invoked.

Mock.Arrange(() => webClient.DownloadDataAsync(Arg.IsAny<Uri>()))
.Raises(() => webClient.DownloadDataCompleted += null, null, e);

Finally, the whole test method ends up like:

[Test]
public void ShouldAssertExepectedDataWhenDownloadIsCompleted()
{
var count = 0;
var e = Mock.Create<DownloadDataCompletedEventArgs>();
var data = new byte[] { 1, 2, 3 };
Mock.Arrange(() => e.Result).Returns(data);
Mock.Arrange(() => webClient.DownloadDataAsync(Arg.IsAny<Uri>()))
.Raises(() => webClient.DownloadDataCompleted += null, null, e);
byte[] exepectedData = null;
webClient.DownloadDataCompleted += delegate(object sender, DownloadDataCompletedEventArgs de)
{
exepectedData = de.Result;
count++;
};
webClient.DownloadDataAsync(new Uri("http://example.de"));
Assert.That(count, Is.EqualTo(1));
Assert.That(exepectedData.Length, Is.EqualTo(data.Length));
}

The above example is done using JustMock SP1. You can further download the code here:

WebClientTest001.zip

Happy coding !!

Back to school : Getting to know F#

Anonymous — Fri, 13 Aug 2010 05:00:00 GMT

This post starts with a basic introduction of F# and finally ends up writing a simple unit test for an F# member. For those who don’t know what F# is all about, Its a product from Microsoft research and now part of VS 2010 family. Actually from Wikipedia it is described as follows:

F# (pronounced F Sharp) is a multi-paradigm programming language, targeting the .NET Framework, that encompasses functional programming as well as imperative object-oriented programming disciplines. It is a variant of ML and is largely compatible with the OCaml implementation. F# was initially developed by Don Syme at Microsoft Research but is now being developed at Microsoft Developer Division and is being distributed as a fully supported language in the .NET Framework and Visual Studio as part of Visual Studio 2010.

Now, let’s first start by creating an F# project using the built in VS template:

Once you hit ok, It will end you up with an empty module project like that follows:

Now, first of all what is a module in F# ? From MSDN library it is stated as:

In the context of the F# language, a module is a grouping of F# code, such as values, types, and function values, in an F# program. Grouping code in modules helps keep related code together and helps avoid name conflicts in your program.

But, it looks to me rather a namespace in C#. Next let’s create the first type in F#.

type IMonkey =
interface
abstract member Name : string with set, get
abstract member Echo : unit -> int
abstract member Execute : unit -> unit
end

In F# there everything is type , if you mark it as interface then use the interface or class keyword. Here is in the code block, we can also see that the first member is declared using the with keyword followed by set, get which states that its a read/write property. The second member has :unit-> int , it means that it takes no argument and returns an integer value. Now, what if we had an argument, then the declaration would look like:

abstract member Echo : arg1 : int -> int

Moving on to multiple arguments, it needs to be written in a tupled way:

abstract member Echo : arg1 : int * arg2:int -> int

The question remains it’s an interface but how we can declare class members . To find out more lets consider this:

type Foo =
class
member this.Echo(arg1 : int) =
10
static member EchoStatic() = 20
end

Here, type declaration is as expected has a class keyword. But for members there is one instance method and one static method. One returns 10 and another returns 20 but first one has arguments too. The declaration is slightly different for implemented or class members where the assigned value acts as a return value and you have to specify the argument(s) via colon format and using commas like:

member this.Echo(arg1 : int, arg2: int) = 100

Of course you have to specify this keyword to let F# know that its an instance member. Now, moving further what would happen if I would implement “IMonky” interface to “Foo” class.

type Foo =
class
interface IMonkey with
member this.Echo() = 10
member this.Execute() = ()
member this.Name with get() = "test"
member this.Name with set(arg1 : string) = ()
end
member this.Echo(arg1 : int) =
10
static member EchoStatic() = 20
end

Here, for each interface implemented should be wrapped with the following block :

interface <name> with

// your implementation.

end

Another thing to notice here that how property getter and setter is implemented using the with keyword. Moreover, the assignment with empty parenthesis like member this.Execute() = () marks that the method is returning anything or a void method.

As we are set with declaring an interface, its members and how it is implemented. Now, lets write an unit test that mocks a member of it. I will be using JustMock here but can be done using other tools like NSubstitute (The new player in town) / Rhino. To do so, first we need to add the following lines before the type and following the module declaration.

open NUnit.Framework
open Telerik.JustMock

Its similar to an using keyword in C#. I am skipping the class declaration and adding instance member into it that can be done in the same way as shown above. Therefore, directly pasting the following code:

[<Test()>]
member this.ShouldMockMethodCallsWithReturn() =
let monkey = Mock.Create<IMonkey>()
Mock.Arrange(monkey, fun ignore -> monkey.Echo()).Returns(10).MustBeCalled()
let result = monkey.Echo()
Mock.Assert(monkey)

One of the interesting piece here is the variable assignment which is done using let keyword. it’s same like doing this in C#:

var monkey = Mock.Create<IMonkey>();

In Mock.Arrange the fun ignore –> monkey.Echo() is equivalent to () => monkey.Echo() in C# but can’t use the () as it means differently in F# therefore used an anonymous variable instead. Everything else is plain old vanilla and hope this introduction to F# helped you a bit that additionally shows a first unit test written with it.

Enjoy!!

Fun presenting last night at BCS

Anonymous — Thu, 01 Jul 2010 05:00:00 GMT

Thanks to everyone who attended my session last night at the West Yorkshire BCS on Agile and Lean development process. The projector failing after only a few minutes meant I had to adopt a good agile approach to the session. It was nice that so many people came up afterwards to say they enjoyed the lack of PowerPoint.

This got me thinking, as I enjoyed not having it as well. All I really missed was a couple of slides one that showed a Kanban board and another that diagrammatically showed the Scrum process, I got round the lack of both of these by pointing wildly at the blank projector screen and asking people to imagine. So if I run that session again I think I will just have that pair of slides and lose the rest. I just need to find a nice means to let me see the text slides, which I used as my speaking notes. I have never been a fan of postcard style notes when presenting, too much to drop, and when I tried using my phone in the past it was awkward, but maybe time to try again now my phone has a larger screen.

If you do want to see the slides you missed they will be going on on the West Yorkshire BCS site ASAP

Speaking at the BCS this week on Agile

Anonymous — Mon, 28 Jun 2010 05:00:00 GMT

Just a reminder I am speaking at the West Yorkshire BCS meeting this Wednesday on the subject ‘Agile is so old hat all the cool kids are doing lean now’.

The meeting starts a 5:45 for refreshments, and 6:30 for my session. The venue is the Old Broadcasting House, 148 Woodhouse Lane, Leeds LS2 9EN (www.ntileeds.co.uk)

Hope to see you there