The integration of dynamic features in C# 4.0 is based on clever architecture that hooks into the DLR. Therefore, the APIs are complex (and well designed!) enough to allow for extensions, so that C# programmers can create their own dynamic classes, either to implement fully dynamic structures for use on the "static side" of .NET programming, or to provide APIs to dynamic languages. This session provides several practical examples!

Node is coming to Windows as a native package, we're all dead excited about it - but.... why?

Bertrand Meyer's Design by Contract is an approach to software design that formally defines the expectations and guarantees of software components. This can provide interesting real world benefits. How does reducing the number of required unit tests sound? How about preventing the violation of Liskov's Substitution Principle at compile time? Code Contracts is Microsoft's implementation and .NET 4.0 ships with support for it. In this session, we will take a look at how easy it is to work with Code Contracts - whether using it in a new project or what issues you may face in introducing it to a brownfield one. 

Very much a hands on demonstration, we'll start with a blank Umbraco install and a set of HTML design files, and end up with a basic content managed website. On the way, we'll explore all the core concepts behind Umbraco, and see how those concepts give Umbraco the flexibility to suite all your clients needs, and you the confidence to know that anything is possible.

Windows Phone User Group meetings are different to most other user group meetings. Not only do they focus entirely on designing and developing for Windows Phone but they're also a lot more interactive than the typical user group experience. Our meetings focus on learning from and with others interested in the platform. We combine presentations, demos of apps that attendees have made and socialising (and yes that usually means free beer.)

As we haven't been able to hold any meetings in the North yet we'd like to hold a mini-meeting at DDD North. We'll combine all the aspects of a typical meeting into a one hour session. If you've developed an app for WP7 or would like to then this is the session for you.

The Reactive Extensions for .NET library from Microsoft’s DevLabs provides an intriguing insight into how .NET in the future might deal with asynchronous or event-based programming. But, if you’ve taken a glance at Rx, it can sometimes feel as though Rx was invented by rocket scientists for rocket scientists. In this session, a non-rocket-scientist will walk through the basics of Rx from scratch, talking about what problem the framework is trying to solve, the simple interfaces that underpin its workings and looking at simple, common examples of where Rx might help in your development today and tomorrow.

Windows Phone 7 having launched in October/November 2010 here is a chance to see what is new with the "Mango" Windows Phone 7.5 update including new features for developers such as multiple Live Tiles, Background Tasks and even more APIs to play with plus a look at the consumer features such as Office Hub and Xbox LIVE Hub improvements added and other things like Twitter integration and more!
Plus maybe some speculation about what is coming in future updates to the Windows Phone platform.

The multi-core scalability issue is being widely discussed these days, and one solution that is regularly proposed involves the application of patterns from functional programming. One of the paradigms of FP is the immutability of data, which is what makes it appealing when it comes to concurrency. In this session, Oliver uses a practical example to show concurrency in action, based on immutable data and other functional approaches.

Behavior Driven Development (or BDD) is an Agile software development technique that encourages collaboration between developers, QA and non-technical or business participants in a software project. It was originally named in 2003 by Dan North as a response to Test Driven Development (TDD), and to Framework for Integrated Tests concepts, from the Customer Test practice in Extreme Programming. It has evolved over the last few years from a better way of doing TDD, through the inclusion of acceptance-test driven development (ATDD) to a full stack agile methodology. In this presentation we will explain how to do BDD and why its not about tools such as Specflow or Cucumber, but about approach. However, we'll give you a taste of those tools, once we have explained why you might need them.

The CQRS architecture has been very hot in the past two years, especially in combination with the Event Sourcing pattern. But by now, I think that the majority of the profession agrees that going all the way is only worthwhile for systems with some very specific requirements.

Yet, I always try to look at new ideas with an open mind. And I believe that the separation of reads and writes in an enterprise system has some interesting advantages. In the past year I have applied this principle to an ASP.NET WebForms project that had nothing to do with web services at all, but gave me a lot of benefits. Even my own initiative, the Silverlight Cookbook, is now based on that.

I'd like to get a chance to explain you why I use this technique, why it has become part of my default reference architecture (regardless of the technology), and I'll share some of the advantages and disadvantages of that choice. Part of that is showing how I've actually used it in a large project.

Level: Advanced

Keywords: Architecture,  Command-Query Separation

The catalyst for this talk was the posting of yet another Framework to help with the Frameworks for the Framework of testing within Frameworks on Twitter.

With recent reports of a man convicted of stealing the details of 130million credit cards by use of SQL Injection Attacks, isn't it time to find out how to defend your systems against them? 

At Build in September, Microsoft will announce Windows 8.

Windows 8 is expected to have features such as support for System on A chip, Touch First Interface and HTML 5 applications – all available through an app store.  It is expected that Microsoft will deliver Windows 8 next year but why wait that long to get ready? Join us for a comprehensive overview of what’s new, what’s bad and how to get connected to Windows 8.

This session will be cover

- Windows 8 Overview

- Developing for Windows 8

- Developer Tooling changes

- Delivering Windows 8 applications

Robert will be joined in this session by Steve Spencer, Development Director of Black Marble.

Command-Query-Responsibility-Seperation (CQRS) is the new 'hotness' but beyond a desire to use the latest 'fad' what might actually lead you to adopt this approach over a conventional layered architecture. We will look at the business drivers behind command and query separation as well as a technique known as event sourcing. We will also look at steps to begin moving your application to CQRS

In the last couple of years unit testing has become increasingly common for guaranteeing the quality of the system during and after construction. Techniques such as Test Driven Development, and more recently, Behavior Driven Development are well known. Yet, you still hear conflicting stories about unit testing. Some claim that introducing a lot of unit tests can hamper development, or that those tests are a maintenance problem on itself. To a limited degree I agree, but isn’t that true for all software that is not been well though off? An important reason for this is that unit tests not always seen as being part of the production code.   Fortunately there are guidelines that help you to write useful unit tests that are easy to maintain, and that will actually help to improve the quality and productivity of your development activities. Also, there are several so-called assertion and mocking frameworks that can elevate your testing practices to an even higher level. Obviously I'm going to uncover all those aspect, and tell you about things like when to use an Arrange Act Assert pattern or when a BDD-style approach is better. In short, if you just started unit testing, or if you have a lot of experience already, I’m sure you’ll find some interesting aspects while I’ll be refactoring a bad test to a great test.  

Level: Intermediate
Keywords: Automated Testing, TDD

So you are being asked to produce web based applications in less and less time, so what can you do about it?

Microsoft has a range of technologies that can help you to do this and in this talk I’m going to give you a brief overview of 3 or them:

1.       Lightswitch is the new Silverlight based application builder, you’ve probably heard how bad this is but let’s see what its actually like.

2.       Asp.Net Dynamic Data can provide a working Asp.Net web forms site in minutes.

3.       Asp.Net MVC using scaffolding support is the newest of the bunch helping you generate the code you need quickly and easily.

Join me as we tour through these 3 different technologies and see what they have to offer.

Hidden deep within JavaScript, there is an elegant, powerful and clean language waiting to be discovered. This subset of the language was documented by Douglas Crockford in JavaScript: The Good Parts. Now, that subset is accessible through the CoffeeScript language. It's like Python and Ruby spent a wonderful night together and spawned a beautiful baby scripting language that is succinct, expressive and compiles to The Good Parts.

Modules, classes, lambdas and more are supported, and you can interact with your existing JavaScript code, as well as all the diverse, wonderful libraries that are out there jQuery.

This session will cover the basics of the language, and interoperability with existing libraries. I'll also show you how to integrate CoffeeScript into your development process, with Visual Studio and other tooling as well as runtime compilation for on-the-fly changes.

You may or may not have heard of Selenium the open source test framework for web applications.

In the session we’ll cover:

·         What Selenium is

·         How it works

·         Best practices for implementing a framework to test your application.

·         The future of Selenium

This talk should have something for everybody whether you are a Selenium virgin or have been using it for a while.

Mobile development is becoming more and more popular. It's also becoming more and more likely that you will have to develop an application or website for use on a phone or other mobile device.

In this session we'll look at the six fundamentals of mobile development. We'll not only look at how they're essential to providing a great mobile experience but also how they can be applied to improve the development you do on any platform. This will enable you to not only create better mobile apps in the future but also improve the apps or websites you're working on at the moment.

FxCop is a static analysis tool which is included with Visual Studio Ultimate and is available for download for Visual Studio Professional and Express. FxCop reads one or more assemblies and applies coding rules to them. FxCop includes a library of existing rules and allows you to write your own. This session covers the subject of writing your own FxCop rules to enforce your own development standards. You will learn how to create rules using different approaches. The first approach is using a simple but laborious instruction walk. The second approach is more sophisticated and uses FxCop’s introspection engine’s “visit” methods. With this knowledge in place more custom rules are shown to illustrate how to implement many rules analyzing instructions, types and resources.

In this session we're going to use the Windows Workflow Foundation as the basis of a new ordering system.  We're look at the strengths and weaknesses of using WF in various parts of the system, as well as how to construct the various types of custom activities that will be required.

As web solutions become more complex and their interfaces become richer the need to manage this growing client side complexity becomes more and more necessary.  

Silverlight is a platform well suited to retro and casual style games that lets you target both Web and WP7 using your existing .Net development skills. In this talk I will show how you can get started in Silverlight games programming, presenting games tips and tricks gleaned from over a decade of commercial games development. Expect plenty of live code samples in Visual Studio starting with a playable game written in under 200 lines of code. Topics will include Space Invaders, Tetris and Missile Command. Oh, almost forgot, all the samples will be written in F#;)

I am sure you have all wanted to do something during an automated build that the out the box solution does not do. If you are using TFS in the past you might have written a custom MSBuild task. The TFS 2010 build system is now based on WF4, not just MSBuild. This means that all those custom tasks you wrote for your TFS 2008 build process will need a bit of work get the features your want.

In this session I will show the options you have to integrate your own custom activities into the TFS 2010 build process including using your old MSBuild tasks all the way to writing your own new WF custom build activity from scratch. Or in other words a descent into the hell of one of the more arcane development processes I have every some across.

It's almost a year since Anders Hejlsberg announced the Visual Studio Async CTP at PDC 2010.  Since then we've had a refresh for VS2010 SP1 which extended the CTP to Windows Mobile as well as including a licence for production use.

This CTP means you don’t need to create callback functions anymore and can write code in the same way as if it were synchronous. The compiler will do all of the heavy lifting for you.

  public async void GetMackemSessions()
  {
     var ddd = "http://ddd.com/Mackem/Sessions.aspx";

     var sessions = await new WebClient().GetSessionsAsync(new Uri(ddd));
  }

In this session we'll see how the GetMackemSessions method works and why it allows you to make a pot of tea while it runs.

More info on the Visual Studio Asynchronous Programming, including download details for the CTP,

http://msdn.microsoft.com/en-us/vstudio/gg316360.aspx

Ok, so this is a little more difficult to arrange with home automation, but controlling lights, heating, curtains and just about every other device in your house just by talking to it, is actually Science Fact. Take a tour around our automated house and see whats possible with a little effort.

So NodeJS is this really cool way of writing non-blocking, server side code, in a really crappy language. Well maybe that's unfair, Javascript has some really, really good bits, and we'll stick to using the really good bits in this session, which follows on from Rob Ashton's introduction. If picked to present, I'll show you how to build a RESTful API in NodeJS, how to use it in Node - including routing - and how to wrap in all up in a package that can be installed using NPM. Not bad for an hour's work, hell, we may even have the odd laugh along the way. :-)

Agile, agile, agile, thats all you hear.  You know about TDD, CI and all the other lovely technical practices but perhaps getting a form of agile working practice is proving a little more difficult.

Enter Kanban! A lightweight working practice to help you visualise and track your work.

Come to the session and I'll introduce you to Kanban, show you how it works, how you can use it and customize it to suit your own situation.

C# has introduced a number of language features that finally make it very easy to employ a functional style of programming. However, from the perspective of an imperative programmer, there are lots of questions surrounding functional programming. Why would I want to do it at all? Should I drop all state information in my apps? What useful functional patterns are applicable to C#? This session uses many practical examples and some theory to answer these questions, and it requires a good understanding of C# 3.0+ language features.

There are three excellent ways to lose lots of money; open a restaurant, own a football club or start a software development company.

Liam will provide a personal and subjective view on some of the tactics that he has found useful when running a software development company, to ensure it enjoys a 1st birthday party.

Liam will be assuming that you can write code, work hard, have commercial
ideas and have clients or sales leads.

We won’t focus on any particular technology or framework, instead topics will include; Support, Testing, Logging, Time/Cost Estimates, Paperwork and Sales Pitches.

Often we add a few lines to do logging at the end of a project or after it's been released to track down that little issue. We're doing it wrong!

In this session we'll explore the Diagnostics functionality built into the .NET Framework and I'll show you some of the hidden gems of Windows in the form of Event tracing and diagnostics.

We'll cover everything from Microbenchmarking through to application wide diagnostics capture and we'll even dig into a little bit of Aspect Oriented Programming.

You'll walk out of this session insipired to instrument your applications to work out what's going on.

Choristes is a new CQRS framework for .NET that allows you to gradually move from a traditional n-layered app to a CQRS based one - and from there, to a fully Event Sourced model with minimal impact on code. It also comes with support for composition of non-functional requirements, prioritized synchronous AND asynchronous event dispatchers, behavioural testing with readable reports while being simple and easy to work with. It draws ideas from other CQRS frameworks while focusing on simplicity, less "magic" and transitioning existing applications to CQRS.

You understand the benefits of CQRS but now you want to implement it. In this presentation we will look strategies for implementing CQRS. We will delve into Event Sourcing, and understand how and when to implement this technique. We will also discuss NoSQL databases and show how they match up with our requirements. Finally we will look at what this means for your overall application architecture

I am a strong advocate for Test Driven Development to build properly maintainable and testable software. However, when UI logic is involved such as a view model in Silverlight's MVVM pattern , I have become more cautious . Especially in Agile projects were that logic changes a lot, I've noticed that those TDD tests were hampering productivity.

After my visit to the NDC in Oslo, I became very excited about testing the UI through automated acceptance testing. Especially the combination of SpecFlow and White allow you to automate your application without jeopardizing the maintainability of your code base. SpecFlow fully integrates with Visual Studio and promotes a process in which the tester or product owner writes the acceptance test criteria, while the developer translates those into code that drives the application. 

In this introductory session I'll take you into the world of Behavior Driven Development and I'll show you how to use SpecFlow to guarantee the quality of your system.

Level: Intermediate

Keywords: BDD, Silverlight, SpecFlow

No, really. This isn’t some clever session title. I’m really talking about controlling your computer with your mind. I’m not making this stuff up. This is real. Today. You put on a headset, you use a C# SDK and you control your computer with your thoughts. Yes, you are reading this right – you mind control your computer. It is a reality and it is possible today. Once you’ve gotten over your disbelief consider the applications. Applications for the physically impaired alone are a whole revolution. Not to mention the possibilities for gaming. Want to be shocked and amazed ? Come and see this session.

Speed matters, to your users, to your boss, but most importantly, to you, especially when you're working on a site a lot, the faster you can get pages to render the more you can get done.

In this session we'll fly through dozens of tips and tricks for speeding up you Web page load times.

We'll discuss Browser differences, HTML, Javascript, Network strategies as well as other methods of making your pages load as quickly as possible.

This will be a beggining/intermediate level session, but if you're a hardcore developer than maybe you'll pick up some things you don't know already too!

Data Access is a difficult area to master.  There are plenty of frameworks such as Entity Framework, NHibernate, i/myBatis.  There frameworks attempt to make data access simpler but while these products are widely used they lead to leaky abstractions forcing us to work around constraints of the technology or introduce the nightmare of trying to figure out what is happening deep down in the frameworks internals.

Facebook, Twitter, Foursquare, etc., a lot of us use the social web these days, and we provide a *lot* of information. Information that your marketing department would like to get their hands on. Why? Because 60% of consumers will act on recommendations made by friends, where "friend" is defined as anyone we've added to your friends list. This means you, as a programmer, are going to have to get involved, because exploiting that data means exploiting an API, and marketing bods are just not going to be able to do that - just ask Rachel :-)

This session is evolving with my own experience of working on the Android platform. I have now grown up from toddling along to doing some proper code.
Mono for Android is also growing up, so we will take a look at its current position and investigate if it is enterprise ready.

Regardless of if you choose Mono for Android or Java / Eclipse you will need to understand the Android architecture, the libaries and the life cycle. So we will start with the basics and progress into building a proper application. We will then repeat the task in Mono for Android.

Don't worry if you haven't played with Java and Eclipse before, I was kind of scared to begin with, but it's kind of ok.

I'm really enjoying working on this platform at the moment and I hope to convey this during my session.

In this session I will talk about the feared Feature Branch and why it is bad. In contrast to this we will talk about how we can move away from the Feature Branch and how this relates to a better team collaboration in CI terms.

When people hear about CQRS and Event Sourcing, they think of performance and scalability at the price of complicated architecture. In practice, the (arguably) biggest thing they bring to the table is simplification. They can help create a cleaner, behaviour focused domain model. They can help deliver required output quicker. They can result in cleaner, understandable tests generating truly readable reports. They can help compose non-functional requirements without having to touch application code. They can promote code reusability across projects without needing tricky alterations. While all of this may sound remarkable, it is surprisingly easy to implement. In this session, we will look at code running CQRS and Event Sourcing to see how all of this comes together.

Our job as a software developer seems to revolve mostly around programming languages, frameworks and Visual Studio. And to be honest, most of us have their hands full with that already. However, our profession includes a whole bunch of best practices that can seriously improve the efficiency and effectiveness of you and your teams, help you to deliver at a higher quality, or involve the business even more. Many of those practices are encompassed by the Application Lifecycle Management concept, but some of you might be more familiar with the term Software Factories.  o what am I talking about? Well, think about Unit Testing (and TDD/BDD), Peer Reviews, Daily builds & Continuous Integration, Brown Paper Sessions, Coding Standards, Common Code Layout, Static Code Analysis, Refactoring, Evolutionary Design, Checklists and Pair Programming.   Do you want to know what those practices are about and why should include them in your toolbox? Join me in this quick overview, or even better, share your own experiences with the audience.   Level: Beginner Keywords: Agile, Scrum, XP, Best Practices

In this session, we go through how to mashup some data from a weather provider and through it on a map with custom icons using the Silverlight Bing Map control

Very little in the way of powerpoint, this is mostly in Visual Studio. This assumes you know nothing about Silverlight and a little about .NET.. Level 100-200 with code in C#

Everybody keeps on about SOLID principles but what are they? and why should you care?

In this session I'll aim to walk through each principle telling you about that principle and examining why you should use it.

Once we've talked about the principle in theory we'll look to how we can put it into practice refactoring an existing application.

Clojure is a fairly new programming language for the JVM (and CLR) focusing on expressive power, functional programming and concurrency. It is designed to be a general-purpose language, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming.

During this talk Joe will give an introduction to functional programming in Clojure and argue that now might be the time to adopt a Lisp.

Behaviour Driven Design/Development is an interesting premise but does it really work?What benefits does it offer and how can we successfully apply the principle it in the .NET world?  We can answer these questions by reviewing the principles around BDD and diving into the technologies that exist in the .NET world that support these principles.

From low level unit focused testing technologies all the way up to the more abstract integration and acceptance level suite of specifications, automated testing and continuous integration we will see that .NET isn’t lacking in choice.  As a bonus we will address the oft ignored testing of our JavaScript project components using tools such as Jasmine and QUnit.

Traditional .NET development frameworks tend to be big, and cover all possible eventualities, and for many projects this is A Good Thing.
But for just as many, if not more, projects, a full web stack like ASP.NET or a complex ORM like Entity Framework or NHibernate is just overkill, and adds unnecessary complexity. This is A Bad Thing.

In this talk, I'll look at a two small, lightweight, low-ceremony frameworks, and how to use them to create applications with less code, less cruft and fewer maintenance headaches. For web applications, we'll follow the super-duper happy path of Nancy, .NET's answer to Ruby's ultra-lightweight Sinatra framework. And for data access, we'll use my own Simple.Data library, to provide ORM-like syntax without the code generation or sluggishness.

Using these tools, in under an hour, we'll create a working version of the VoxPop site (the full version of which will be active for the DDD North event).

Caliburn.Micro is a lightweight, fully-featured, open-source MVVM (Model View View-Model) framework that supports WPF, Silverlight and Windows Phone 7.

In this session Barry will give you a brief overview of MVVM and then show you how to use Caliburn.Micro to go from an empty project to a fully working Silverlight application. Along the way, Barry will demonstrate how Caliburn.Micro takes advantage of Convention-over-Configuration to bring together your View-Models and Views. He will also show you how any UI event can routed to your View-Models and how you can data-bind directly to your View-Models. You will also learn how to work with nested views and how to configure Caliburn.Micro to work with your favourite Dependency Injection framework.

Every relevant browser now has the ability to run WebGL applications - let's have a looksee at how we can leverage this to make "teh shinies",  either as games or actual tools to help people Do Stuff.

We'll cover what WebGL is, what browsers support it, how to set it up, and cover the libraries that are out there that can make things easier for us.

We'll also look at why a lot of people consider WebGL as an important step for the web, and why we should be embracing it rather than running to the hills for cover!

Arguably the most innovative and forward thinking feature of Windows 7 is its multi-touch support. And it should be no surprise to see that WPF 4 boasts the same multi-touch support that utilizes this Windows 7 multi-touch support where available. In this session we will explore this new feature in WPF 4 and see what we get for free (i.e. without having to do any work), what you can get with only minimal additional work and what takes a bit more time and effort. Along the way we’ll discover the basic touch support together with support for rotation, scaling and inertia as well as how to handle low level touch events using the raw API. Please note: the presentation shows true multi-touch – this is not a trick with two mice simulating multi-touch.

Okay, we've had an introduction to node.js, and an "advanced" how-to-build-a-web-application in node.js, but how about something a bit more interesting, something that offers some complexity that we'd have a hard time dealing with somewhere else.

VOIP apps? Multiplayer gaming servers? All these things offer a world of complexity that node.js offers to deal with very elegantly.

Let's look at some lessons learned building a multi-player game in Javascript, sharing the same code on the client and the server and managing communication between our clients, our server and all that state we have flying around.

This session is not for the faint hearted, but we'll come away having seen that this kind of experience has many lessons we can take into our more financially viable business applications.

More and more companies today are spending needless money on testing applications. Realistically, as developers, we can automate the majority of functional tests. SpecFlow is one way of automating these tests. In this session I will use use WatiN to help drive automation of business critical functions of your web based product. I'll touch on how SpecFlow helps us create tests that move us towards a BDD style of testing

- What is SpecFlow
- How does SpecFlow relate to BDD
- The use of WatiN to test business critical functionality of a web product
- Why automation may not always be the answer and how things can go wrong

JavaScript is going from a niche tool to pretty much a requirement in modern times. It is an extremely flexible language and as such, it is quite easy to end up with an unmanageable mess that "works". We seem to focus so much on unit testing everything server side, yet pay so little attention to what runs on the browser. In this session, we'll look at a clean approach to using JavaScript "objects" - not mimicking languages like C# but using what's already in the language. We will quickly look at how we can use these objects with an MVVM framework called Knockout. We will use QUnit to unit test our code and then integrate it into a build script.

There are plenty of framework options in .NET.  We have the big mainstream web frameworks like ASP.NET WebForms and MVC, the ORM abstractions and DataMappers in the form of Entity Framework, NHibernate and iBatis and services such as WCF requiring large amounts of careful configuration to get right.   Unfortunately these frameworks can get in the way, abstractions breakdown and leak and eventually we end up fighting against the frameworks limitations.

Back in 2006 Ted Neward wrote an essay entitled “The Vietnam of Computing Science” (http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.aspx) citing Object/Relational Mapping as the Vietnam of computing science and how things always start really nicely but soon turn sour with increasing load time and underperforming queries and a whole host of other problems.

In this talk I will look at how we get engendered in battles with ORM without even realising it and ways of getting out of ORM Vietnam once you are firmly entrenched in the battle.

The new version of Windows Phone 7 (codenamed mango) addresses some of the platform's previous limitations around multitasking. This isn't typical multi-tasking though as the platform has to balance the needs of the application with the need to preserve battery life. In this session we'll see what's now possible when your application isn't running in the foreground and how to create applications that use the new functionality and behaviour now available.

Will I be cast as the Panto Villain or the Panto Hero? We all have opinions on how best to write code, in this session I'm going to subject you to mine.

We'll fly through what I think 'good' and 'bad' code is. Some tips for what direction to follow, and you can spend the session booing and hissing at things you don't like (Just like a real pantomime).

We all like to code a certain way, Microsoft issues coding standards back with .NET 1.1. Realistically, they were a bit 'meh'. So where are we today many years later and a few years wiser?

The collective intelligence of the development community, many open source projects and dozens of code reviews have brought me to a point where I know what code I like and I know what code I hate. Do you want to know what I think? ;-)

CI servers are powerful pools. In most cases we use them for automated builds and running of unit tests. In this session we will actually use our CI server for more than just these things. We will talk about:

How to run code coverage

How to create release packages for product ready deployment

How to create sql differencing and rollback scripts

How to create NuGet packages

How to automate the creation of documentation using SandCastle

(and more if I have the time!) I will demonstrate this using TeamCity. 

The choice of unit testing frameworks in .NET offers a powerful TDD experince. From NUnit and XUnit to MbUnit there is a rich and powerful range of features and flexiability available to you. However, chances are you are using only half the features of your chosen framework. This sessions shows you the full range of what each framework can do and you can be effective in your TDD with the framework.

If you have been building enterprise-class Silverlight or WPF line-of-business applications, you must have been using the Model-View-ViewModel pattern. In spite of the many classes and interfaces .NET offers to ease development of MVVM apps, it continuous to be difficult to get the most out of those patterns: maintainability and testability. Worse, the asynchronous nature of Silverlight doesn’t really to keep difficult constructs out of your code base. Microsoft’s Prism project attempts to remove that difficulty, but feels over-engineered too me.

The Caliburn Micro project, a spin-off of the bigger Caliburn project, is an entry-level and modest convention-based open-source framework that saves the Silverlight, WPF or Windows Phone 7 developer from many of those challenges. Whether you’re dealing with binding controls to VM properties, the complexities of asynchronous programming or the communication between VMs, Caliburn Micro offers some very elegant solutions. I’ve recently finished an enterprise Silverlight 4 system that employs WCF Data Services and NHibernate. I’ve become more than enthusiastic, and I’d like to share my experiences with you.

Level: Intermediate

Keywords: TDD, Silverlight, Caliburn

CoffeeScript - “a little language that compiles into JavaScript” has been making a lot of noise in the web community with its inclusion in Ruby on Rail v3 and its swift rise in popularity on Github.

Umbraco isn't just a CMS, it's a development platform. Learn how to develop on top of Umbraco aswell as the plethora of ways to extend it. From event listeners to custom sections and trees, the only limitation is your imagination. 

Configuring development and production environments from scratch can be and extremely boring and time consuming task, especially when you have to deploy 2, 3 or 50 servers. 

Continuous Delivery is all about allow features to be delivered in a more timely and reliable fashion. In this session, I will:

- introduce the concepts of continuous delivery, through continuous integration; and automation of the build, test and deployment process

- talk about Version control techniques for Continuous Delivery 

- talk about the Roadmap to Continuous Delivery Adoption-

 talk about the Pitfalls, Objections and Obstacles

In May 2008 Microsoft released StyleCop. StyleCop does for C# source code what FxCop does for assemblies – it applies ‘good practice’ rules to your source code. This means all those controversial code beauty issues like spaces, where to put curly braces, how and when to use blank lines and over 150 similar rules. This session gets you started using StyleCop, investigates a selection of rules, shows how to integrate StyleCop into Visual Studio and your build process and finally shows how to write your own custom rules. This is a low tech session on an essential tool that all C# developers should be using.

So you've heard about agile and scrum but what's involved? How can it help?

In this presentation I'll give an overview of the basics of scrum for those that either don't know about it or haven't used it before and then attempt to outline the common problems that people come across once they've started using scrum.

10 common security mistakes that developers make when developing web applications and how to avoid them.

Covers topics such as XSS, SQL injection, correct permissions and securing your web.config file

.NET 4 has some very nifty features to aid the creation of multiple threads of operation. In this talk I'll be introducing those features and demonstrating what they can do for you, how you can benefit... And importantly, what you shouldn't do if you want to maintain your sanity.

During this session we will attempt to write a native Android app (Yes that means Java) to view photos from Facebook and set them as the background image on the device.  Along the way we will see the basics of intents, activities and layouts.  As well as showing the strange little bits of Java that threw this poor .NET developer!

The Web, as we all know, is all about pull; the client controls the flow of data. But in the increasingly connected world, users expect information to flow to them, an ideal that just doesn't fit with how the Web works. In this session we'll explore the options for pushing data from the server to the client, covering topics such as client polling, WCF, Silverlight and new standards such as WebSockets.

Microsoft Research describes F# as "a scripted/functional/imperative/object-oriented programming language". Combining all those aspects in one language is certainly not an easy task, but they've done a good job of it. F# is interesting both as a language to actually consider for your projects and as a source of features that might make it into other .NET languages tomorrow. The session uses many examples to give you a good general overview of F#.

C# 4.0 supports the new "dynamic" keyword, which promises easy interaction with those parts of the programming world that are, well, dynamic in nature. In this session, Oliver walks you through several scenarios, interfacing with dynamic programming languages as well as Automation, and explaining some of the basics of how dynamic calls work in C#.

As developers who work in a team, we need to continually make sure that code we check in to source control works integrates with our existing code. In order to do this we need to get feedback from user check ins. If we don't test code integration how do we know that our code still works? 
CI processes and CI tools can help us to do this in an effective way. In this session I will cover 
· Benefits of CI 
· Different types of CI tools  
· Tips on choosing the right CI tool 
· CI as a form of feedback to development teams 
· CI as a tool for release preparation 

Domain Driven Design by Eric Evans is one of the classic texts on the subject of domain modelling. Many of its terms, such as repository, have entered developers everyday language. But how much do you know about DDD? In this presentation we look at how DDD helps us model a domain. We will introduce core ideas such as Ubiquitous Language, and we will explain how the classic patterns: Aggregates, Entities, Repositories etc. help us to build better domain models.

Apache Hadoop is an open source software for reliable and scalable distributed computing. It is designed to process large data sets across clusters of computers using a simple parallel processing model.

This session will explain the concept of Map Reduce using Apache Hadoop through simple sample programs.

The Windows Phone 7 Marketplace is growing rapidly  - already there are 30K apps a bit over a year after launch and the pace of growth is speeding up and standing out is getting more difficult.

Having been involved in developing some successful Windows Phone 7 apps from start to finish like Coxktail Flow, a top rated app and one of the few Microsoft showcase apps and App Flow, a recently launched app steadily climbing the charts with even higher ratings than Cocktail Flow.

In this talk I'll be going through the key steps of designing, implementing and launching these apps, finding the common patterns developers can use to increase their chance of breakthrough on the WP7 market.

Building enterprise-class WPF or Silverlight line-of-business applications has many challenges. That's why I started the Silverlight Cookbook initiative this year. It's a CodePlex site that hosts a Silverlight 4 LOB application where I try to solve technical challenges based on my own experiences from being the tech lead in major projects . The Cookbook uses a number of well-known solutions like Caliburn Micro, NHibernate 3 and WCF Data Services. But it also includes aspects of the CQRS architecture. Besides that, I use it to share my believes about writing good maintainable unit tests. I'm still working on the Cookbook and see it as an ongoing project to try new ideas that I pick-up from the community or to integrate proven solutions from my own projects.

In this session I'll give you an introduction to the most important technical solutions, and I'll try to give you the right background info to get the most out of the Cookbook in your daily job.

Level: Advanced

Keywords: Business Applications, Silverlight, Architecture, Caliburn, Command-Query Seperation, ORM, WCF Data Services, REST, Domain Models

Remarks: This is a talk that can easily take two slots in a row. It covers both front-end and back-ends topics.

The realtime web isn't just another buzz term. It represents a group of technologies that have enabled engaging interactive applications to be developed. In this talk I'll discuss the realtime web and what it means to businesses and developers. I'll also cover what technologies and methods can be used to build realtime applications, from self-hosted Comet servers to WebSocket powered cloud services, and the methods available for realtime server to client interaction. Finally I'll build and demonstrate how realtime web technologies can be used to build a fun, engaging and interactive application (ok, it's a game).

I've attempted to melt your brains with a 10 minute braindump at DDD9 of what we can achieve with CUDA - but how about an hour where I actually give a proper explanation of what we can do here?

So, you feel the need to stand in front of your computer and wave frantically at it? You do? then you should come to this session and see how all that gesticulating can be harnessed. Will will have a look at how the Kinect can recongnise your skeleton, understand what bones are, and maybe have a go at controlling some of your house with various gestures.  Might even get fit as a result!

So you’ve written your ASP.NET MVC application and you want it to work in another language ? Then this session is for you. In this session we will cover localizing HTML and HTML Helpers, positioning resources, creating WebViewPages for localization, localizing and globalizing Data Annotations, the importance of Resource Manager abstraction, localizing and globalizing JavaScript, localizing URLs and more. No previous experience of ASP.NET localization is required.

In the past year I served as the team leader of a Scrum team consisting of a total of 9 developers and 1 tester. Obviously we applied the well-known practices of Extreme Programming like TDD, Pair Programming and Peer Reviews. But in addition to the challenge of building a functionally complex suite of products in a very dynamic environment, I noticed that a team of this size demands a lot of 'soft' skills.

As you might expect from a good Scrum team we have held a retrospective at the end of each sprint. After reading back on these reports, I came to the conclusion that those observations may be particularly useful for future projects . That's why I want you to join me in this session to hear about the agreements, methods and choices that worked well and which didn't. I would have been very happy if someone would have told me about those before I started that project.

Level: Advanced

Keywords: Agile, Scrum, XP, Best Practices