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

Herb Sutter famously coined the phrase the “Free Lunch is over” back in March 2005, when it became clear that processor clock speeds were no longer obeying Moore’s law.  If developers wanted applications to go faster they could no longer rely on greater clock speeds, they would need to think differently and restructure their code to take advantage of multiple cores in order to get better and better performance.  It turns out parallelizing all but the most trivial piece of code is challenging.  .NET 4 attempts to assist the developer by providing support in the framework to assist parallelising algorithms through the use of parallel constructs like Parallel.For, and Parralel LINQ and a variety of concurrent data structures.  The framework vendors would like you to believe that the free lunch is now back, but whilst they can deliver a moderate free lunch, if you truly want a gut busting free lunch you will have to deploy a range of tricks for your algorithm to take full advantage of those multiple cores.

This session will look at using Silverlight as your weapon of choice to target the Windows Phone 7 platform. This session will focus more on the platform specifics including:

·        Theming

·        Input & Navigation

·        Push Notifications

·        Location Service

·        Connected Apps (WCF)

·        Lifecycle (Tombstoning etc)

·        Launchers, Choosers

We will also take a look at how to architect an application using the MVVM design pattern.

This presentation will be revision for some and new for others. In it we'll cover the process of calculating which algorithm is more efficient than another. This seems to be a forgotten skill since the advent of managed environments like the JVM and .Net, we assume that the environment knows best, but does it? I'll show you how to calculate algorithmic efficiency and demonstrate why it's still important in the age of .Net

BDD is an Agile methodology that aims to get business and development folks collaborating.
F# is the powerful new programming language from Microsoft bundled with Visual Studio 2010.
Use both to test your .Net code for fun and profit!
 
Scenario: Deliver customer value
 Given collobaration with customers to produce user stories and acceptance tests
  And some awesome .Net code
 When a BDD framework that executes plain text specifications like SpecFlow or TickSpec
  And F# to write the tests
 Then profit!

Writing tests with F# is a great way to learn the language, this talk will take you through common steps with live code examples.

RavenDB is a relatively new document database written by Ayende Rahien as an open source .NET project.

HTML5 has been around for a while, Chrome, Safari, Opera, Firefox and IE all now claim support, but is it worth it? What can it do?

This talk will demonstrate some of the new HTML5 features, with the help (or hindrance) of some, more or fewer, of the above browsers. As the browsers, and the standard evolves, this talk will attempt to show the current state of play near the cutting edge. And yes, some of it does work in IE6, with a little bit of work.

A mobile panel featuring some of the top mobile application developers in the UK. Should create some interesting discussions!

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.

The best place to start your development is on solid foundations and in the web world, that means with a sound knowledge and understanding of HTML and script and those little browser quirks and tweaks which mean you can wrestle the best performance once server-side code has done its job. This session looks at the HTML5 Boilerplate project, the tips and tricks we can learn from it (cross-browser normalization, performance optimizations, even optional features like cross-domain Ajax and Flash) and suggests some additions we can add to it on the server-side. 

So you’ve written your Silverlight application and you want it to work in another language ? Then this session is for you. World-Readiness is all of the work that a developer needs to do to globalize an application and make it localizable (i.e. capable of being localized). Whereas these concepts are well established in Windows Forms and ASP.NET, Silverlight is not only a cut-down version of the .NET Framework but also cross platform and client-side. In this session you will learn how to localize Silverlight applications using .resx files, download culture-specific resources on demand so that users only download resources for the culture they need, understand what System.Globalization types and properties Silverlight does not support and why, what globalization and font support you can expect on Windows and the Mac, what the Silverlight installation user experience is for non-English users and what language support you can expect from the Silverlight framework.

WPF is the latest desktop application framework from Microsoft. With WPF the mix of XAML, Visual Studio and Expression Blend allow the creation of visually compelling applications. Silverlight took .NET and the WPF framework to the web, and more recently with Windows Phone 7, Silverlight has made its way to the mobile platform.

Whilst the possibility of using the same skills for developing on the desktop, web and mobile platforms is an exciting prospect in itself, what I think is more interesting is the possibility of sharing the same codebase between all three.

Silverlight is a stripped down version of WPF, with a few added extras which relate to the web context it lives within. WP7 uses a further stripped down version of the web-based Silverlight, again with a few extras relating to the web platform (touch and gesture support for example). What this means in practical terms is that in order to maximise the shared codebase, you need to target the shared parts of each API as much as possible.

In this talk I will help you navigate the differences between the three platforms, discussing practical techniques for code sharing, using existing patterns such as MVVM and some more traditional ones as well. I will also discuss how applications can be specialised for each platform to make best use of the platform's form factor and environmental constraints (for example touch interaction on the phone). With these techniques, a significant amount of code can be shared between the three platforms.

With so much customer interaction happening on social web sites right now, companies need to know what kind of information they can extract from them. In this presentation, I'll show you how to find out such information as: where you customers are, what they want, what they think of your products and who are the influencers in the network. This session will be a mix of theory and coded examples, fun and useful for anyone who works at a company who already make use of, or who are thinking of making use of social media as a marketing platform.

When developing in Ruby and with Rails tests aren’t just a nice thing to have in your code base they are essential to make sure your code will even run. In this talk we will look at test in both plain ruby and in rails. We will look at the various frameworks out there, when to use what and how to keep your tests maintainable and of constant value.

Out of the Parallel Framework Extensions came a new API for doing asynchronous programming.  This API has now been adopted by the.NET 4 Base Class Library as a means to write multithreaded applications, replacing the traditional Thread class and QueueUserWorkItem approach.  This talk will provide a whirl wind tour of the new API demonstrating how to implement a variety of asynchronous patterns utilising new .NET 4 and Visual Studio 2010, and highlighting various gotcha’s they are just simply inherent in asynchronous programming.

 

 

How would you like to build Silverlight Applications which are data driven without writing any code, just draw them, press a few buttons, and hey presto you have your Silverlight Dashboard in minutes few?  Well this you can do - with Visio Services in SharePoint 2010. Visio? That's a very un-cool app? SharePoint? That's for document management right?



Wrong on both accounts, cast aside your preconceptions, and come and see a lightening tour around one of the coolest yet least known and most powerful features of SharePoint 2010. And I mean cool. And powerful. Anybody can build a Data-bound Silverlight Dashboard in minutes, even Dave, and he will talk you though why, how and the whens of doing it.   See you there! 

Makes my heart go boom, boom.

Really, I have no idea why I'm quoting Girls Aloud lyrics.  Errggh, back to business, yes a session.  I guess I'm playing around lots with Windows Phone 7 just now.  If you want a session on WP7 then I'll give one on wherever I am on this by the end of Jan.  I guess voting for a session without knowing what will be presented is risky but I am

raising the bet, and calling the shots now on me, oooh

it really doesn't faze me, how you spend your time, ooh, ooh

All of a sudden it's a doddle to make web apps for mobile devices.

We'll whiz through the goals of jQuery Mobile and ponder which devices we can target.

Romping through some code examples in George's usual unorthodox style, we'll build up pages using the cunning Unobtrusive techniques that jQuery Mobile is imbued with. We'll see how interactions can be added and how elements can be styled using jQuery UI theming.

C# 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.

Getting started on AJAX with jQuery:

We'll hurtle straight into using jQuery to handle your AJAX; Rummage about in code, 'hijaxing' links and doing fashionable things like Progressive Enhancement; JSON and JSONP; solutions to get around the 'Same Domain Policy'. We'll work through a bunch of examples to POST and GET data from various sources. If there's time we'll explore more of jQuery's AJAX methods and events and maybe even look at live ajax event handling in large single-page apps.

George's presentation style is entertaining and leaps along at quite a rate. (If you've attended George's Get Going with JQuery session then you have an idea what you're in for.) There will be a few minutes' refresher on jQuery basics then it's non-stop AJAX. Some experience with JavaScript will help but if your world is C# and curly brackets then I'm sure you'll be as happy as a pig in, er, shift+]

This talk takes a look at the dynamic keyword, new in C# 4, and aims to cover the things which rely on this feature (such as COM interop in Silverlight 4); highlight some neat use-cases that will be useful across a range of projects; and maybe show that dynamic can grant some of the "I wish I coulds" that crop up in day-to-day programming. Also includes a look inside my open-source projects: IronMock, which uses embedded IronRuby to mock objects for testing; and Simple.Data, a data access library with magic methods based on the DynamicObject type.

PRISM 4 now has out of the box support for MEF, we look at how we can use it and why MEF is an ideal addition to the framework.

Or: How to bend Linq syntax to your will.

These days, monads are the "celebrities of programming language theory". But they also inspire fear in the hearts of lowly imperative programmers like myself. However they are a very useful and powerful abstraction and they pop up everywhere. C#'s Linq syntax is Monadic, for example. Having an understanding of Monads will give you the conceptual tools to greatly simplify many programming challenges, from dealing with nulls and managing state, to asynchronous programming and parsing. This talk will be mostly C#, but I will also be introducing a little F# and even some Haskell.

Anders Hejlsberg announced the Visual Studio Async CTP at PDC 2010.

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 GetDDD9Sessions()
  {
     var ddd = "http://ddd.com/ddd9/Sessions.aspx";

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

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

More info on the Visual Studio Async CTP, including download details at,

http://blogs.msdn.com/b/csharpfaq/archive/2010/10/28/async.aspx

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

Windows Virtual PC is a free virtualization download from Microsoft for Windows 7. It allows you to run and maintain multiple virtual machines running different Microsoft operating systems in different configurations. Virtual Machines allow you to test your software in different configurations without the need for buying and maintaining separate physical machines. Unlike previous versions of Virtual PC, Windows Virtual PC includes an API for programmatically controlling these virtual machines. This session describes this API and shows you how to use it to run automated tests on multiple platforms. Subjects covered include basic use of the API, logging on to virtual machines, various methods for copying tests to virtual machines, running processes on virtual machines and collecting test results.

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#.

An energetic and entertaining introduction to jQuery and all it's cross-browser loveliness:

Applying jQuery to your pages with Progressive Enhacement; the CSS-like selector syntax; binding and handling events; effects; plugins and ajax. Then perhaps we'll do a little more ajax. If needed we'll chat about closures, JSONP, cross-domain issues and solutions. Lots of code and demos along the way and avoiding yawny slides.

A great session for those fairly new to jQuery or who would like to do more with it. We also dive into some advanced usage and best practices.

Described by a previous audience member as "Eddie Izzard does tech".

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

In this session I'll aim to walk through each prinicple telling you about that prinicple and examing 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.

Everyone has heard of functional programming these days, and many people are curious about its wonderful promises. On the .NET platform, some of these promises are hard to demonstrate due to lacking infrastructure. This session aims to show ideas like automatic parallelization or bug fixing in running systems on the basis of the existing platforms Haskell and Erlang, and compare with .NET.

I want to shine light on some of the parts of Mono that have been developed up above and beyond the standard framework.

Some of the libraries that have been built by people in the Mono world and
some of the experimental ideas that people have been playing with.

It's one week to go-live and you've been asked to check the application performance. A quick check show's it's going to be a long week for you. In this session we will use lots of practical examples to show how to use standard tools to examine the performance of an SQL Server application. We will see how to track down problems with poor design, slow SQL and locking. Then we'll see how to get some quick wins so that you have some chance of getting home on time.

In this session I will look at the specific challenges and decisions I made in redefining a desktop based Silverlight app to work on a Windows Phone device.  Along the way I will cover the Windows Phone advertising platform, the submission process for Apps into the WP7 marketplace and will also share details of the proceeds I have earned from my current portfolio of WP7 applications:

http://rd3d2.wordpress.com/2010/10/11/windows-phone-7-launch-apps/

(Oh, and quite possibly I will be handing out Channel 9 guys to anyone asking good questions.)

In the realm of agile methodologies, Scrum is one of the more well known approaches for software development. Despite its popularity, there plenty case where teams have struggled using Scrum. In this talk we will look at Scrum from the perspective of the first principles from which it evolved; and how those principles help us deliver better software. At the heart of the discussion we will go deep into the origins of Scrum and the assumptions and principles it depends on. It also has been ten years since the Agile Manifesto was drafted. Scrum is but one of several agile methodologies represented on that great day. This talk will touch on the other methodologies and how they differ with or complement Scrum.

Windows Server AppFabric is the new home for code name "Dublin" which are the WF extensions and hosting environment announced way back in PDC 08.  We take a look into the murky depths to see what is and how it helps us with our Workflows.

In this session we will look at how we can use a number of popular .Net OSS projects to develop a real world application. Based on production code, we will look at how using a combination of NHibernate, FluentNHibernate, Castle Windsor and a number of other OSS (AutoMapper, MvcContrib, FluentMvc) to reduce the friction of application development and remove a lot of infrastructural concerns. We will explore how we can leverage these tools to drive a convention based development experience and make it easier for ourselves and team mates to write applications and deliver what the client wants.

In .Net 3.5 SP1 Microsoft introduced Asp.Net Dynamic data a technology to help build CRUD websites quickly (don't tell the CQRS boys).

Since that time it has matured a little, the functionality has been made available directly in web forms and some functionality has been taken and utilised in parts of MVC.

In this session we'll look at using the Dyanmic Data functionality, what you can do with it now and how MVC has used some of it.

Along the way we'll see what trouble we can get into building some code to demonstrate its capabilities.

Joel Spolsky once said that rewriting software from scratch is the single worst strategic mistake a software development company can ever make.[1] We all know of the Netscape story and the never-released v5.0. So as a developer how do you react when you're faced with the fact that there is little other choice than do exactly what you're told you should never do.

During this session I will describe how as a team we are managing to beat the odds and rewrite our main flagship product from a legacy platform into VB.net; as well as describing the decisions behind the choice of language, the choice of development methodology, how we built the project plan, how we learnt from our mistakes and our successes, how working with Bournemouth University and their study of our rewrite has helped us, and whether or not we still think it's something you should never do.

[1] Joel Spolsky, Things You Should Never Do, Part I
http://www.joelonsoftware.com/articles/fog0000000069.html

Your application is being promoted to production. More to the point you have been told that your database and BI will now be hosted on a SQL Cluster. Will this matter? Will it effect your application? Should you have known about this during the design phase? Why are the DBAs doing this to you?

This presentation will show you what *exactly* is a SQL Cluster, providing you with a good understanding of what this will mean to you, what you need to do differently for your development solution and why you should even care.

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.

The build service of TFS 2010 is now workflow based. This means that if you have created custom MSBuild tasks for the previous TFS 2008 build system they are not instantly useful to you now. So what are your options if you wish to add your own bespoke step to a 2010 build?

In this session I will discuss the various options open to you up to and including the creation of a coded custom activity and all the hoops you have to jump thought to get it working.

Or, how to architect a codebase wide refactoring project. In this advanced refactoring session, we'll look at such things as functional decomposition, code criticallity, the correctness continuum, sub-tree refactoring index and prioritisation. All these terms will be defined, explained and demonstrated, so that by the end of this presentation you'll have the knowledge and confidence to architect such a refactoring project... or eat an elephant, whichever you prefer.

In this session I will introduce the NoSQL philosophy before going on to compare and contrast the strengths and weaknesses of the relational model versus the NoSQL model, showing scenarios where you would choose one over the other and explaining why. I will complete this session with a demonstration of an application written with a NoSQL storage layer and explain the advantages that accrue from that decision. By the end of this session you will have the answer to the question posed in the title.

With the newest version of Windows Home Server, codename Vail, out soon, this talk will be what having your own server in your home.
No, you dont have to have a temperature controlled room, and lots of noisy fans and cables.
What you do get though is a way of shring media around your house and protection from deleting an important file from your laptop, with automatic backups.
Media center can schedule TV recording and ask Windows Home Server to distribute it around the house...
Theres loads more, but you'll have to listen to the session for that..;-)

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.

So you've heard SysAdmins and DBAs discuss PowerShell but you're not sure what it is or how to use it. Powershell is a powerful scripting engine that can be used to automate admin tasks making more efficient use of your time. This session will introduce Powershell so that you can add it to your toolbelt. I'll discuss some general admin tasks that can easily be automated with PowerShell and look at some developer specific tasks that can benefit from PowerShell knowledge.

C# 3.0 and LINQ have made anonymous delegates and closures a hot topic. C# 4.0 improves on them. But these "functional" features have applications beyond messing about with IEnumerable. In this session I'll present 10 simple and not-so-simple uses of first-class functions to help cut down on repeated code and improve maintainability; hopefully you'll discover a new and exciting way of approaching coding problems.

To many SharePoint is a mystery. Is it a document management system? Is it an Intranet Portal? A Web Content Management System? Who knows?  Probably nobody will ever decide. What is a fact though, is that it is probably Microsoft's most successful product outside of the Windows platform itself. 



Many an ASP.NET developer who have stuck their toe into the SharePoint waters have walked away confused and dissappointed, saying it's too constraining a platform.  Dave is here to tell you that is not the case.  Like any platform you need to know the fundamentals, and that's what he'll cover  in this sesson.  He'll cover how to build a highly stylised and branded SharePoint Internet Facing Website template which you can reuse over and over again from first principles.



Bring with you your ASP.NET, your XML/XSLT, your HTML and your CSS and of course your .NET code, and you'll see that anything is possible on the SharePoint platform ...

The cloud has moved in and presents us with new opportunities and challenges. Microsoft’s cloud offering for application development, the Windows Azure Platform gives us a familiar environment to deploy our applications to but also a number of additional features that must be considered in our design. Azure will affect the way we architect our applications, the way we code, test and deploy. This talk highlights some of the new possibilities that Azure opens up for us. It will also highlight some of the new challenges we will face as developers, and finally some productivity tools that can help us on our way.

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.

Imagine you could engrain your process within your source control. Making your use of source control mirror your scrum/kanban/latest fad board. It would be impossible for a story to pass through your development cycle without it following your process. Sound interesting? I'll describe how you can enable this through a DVCS such as Mercurial or Git.

DBAs can be an awkward bunch. They either want to take all the control away from you for your development servers and databases or leave you to struggle completely on your own. This presentation will look to helping you find and achieve the right balance.

So how do you ensure your DBA gives you more control over your development environment? What do you need to ask them for and what do you do when you get it?
Once we have established how you (the developer) can obtain control over the database development platform, this presentation will demonstrate how you can:-

1. Use your new found DBA skills and rights to empower and speed up development and testing
2. Maintain the database environment easily and with no or little fuss
3. Understand what problems you might encounter when your databases are promoted to production

Since this presentation will be given by a real world DBA, any rotten food or empty bottles you may have on your person will be confiscated on entry.

Nearly everyone has their chosen IOC container these days, and mine is StructureMap.

We go down into the depths of Workflow 4, looking at Bookmarks, Persistence Extensions and lots of other interesting dark corners.

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!

The Mono Project is an open source, cross-platform, implementation of C# and the CLR that is binary compatible with Microsoft.NET that allows you to deploy .Net applications on non-Windows OS'.  Monodroid is their port of the the framework to Android to allow for C# based development on Android handsets.

Microsoft’s Azure Table Service provides a low-cost solution for storing and searching structured data in “The Cloud”. Plus, it’s one of these cool new NoSQL data stores that everyone’s talking about. But it’s very, very different from SQL Server and other relational databases, so is it the right solution for your project?

In this session we’ll look at how Azure Table Service works and how to use it. We’ll look briefly at the high-level Data Services SDK, talk about its limitations, and then quickly move on to the REST API and how to use it to improve performance and reduce costs. We’ll make-up some pretend real-world problems and solve them in new and interesting ways. Code will be written. We’ll denormalize data (for fun and profit). We’ll talk about how certain social networking sites can deal with huge volumes of data so quickly, and why it sometimes go wrong.

We’ll also cover some of the very useful features of relational databases that Azure Table Service doesn’t provide, and whether they can be reproduced in other ways. Acronyms such as ACID, BASE and CAP will be tossed around with gleeful abandon. And we’ll discuss the relative costs of Azure Storage Services (including Blob, Queue and Drive) compared to SQL Azure, and ways to appease the bean-counters.

So many developers limit their software to the virtual world inside their computers. I decided to break free from those virtual shackles and would like to inspire you to do the same.

Powerful systems on a chip called microcontrollers are becoming increasingly affordable. This, combined with greater accessibility, provides the opportunity for software developers to reach out into the physical world.

This session will cover the fundamentals including equipment you will need and where to buy it, setup, development environments, deployment, circuits and debugging. The demonstrations will show you how to code in C and C# using the .Net Micro Framework. If you have an interest in robotics, automation, monitoring or control systems but don't know how to get started, this is the session for you.

Ever thought that {braces} are too ugly?

Ever wanted to write code that's easier to read than to write (yes Perl and PHP, I'm looking at you)?

Ever found C# generics aren't generic enough? Or wish var was a bit more flexible?

Want to see what .Net looks like if the C# dynamic keyword was more than just one way of doing things? If dynamic was the root of the language itself?

Ever wanted to write code like this?

SpreadTheWordResults = [tweet(x) for x in MyBlogPosts() if title.contains("awesome")]

Come and see what IronPython can do for you.

In a 'left-field' session, Dave will cover the whys, hows and the maybes of Quantum Computing: a subject which might seem to have little relevance when you go back to the office true, but it is gathering interest and momentum as real production Quantum Devices get installed in the City of London to help secure sensitive information, and as a stream of technological breakthroughs bring these elusive computers ever nearer!

Dave will cover the reasons why scientists are researching Quantum Computing, why Quantum Computing is different from the computing of today, and why technologies like SSL may have met their match the day the first real Quantum Computer hits the streets ...

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.

Bringing together a bunch of the latest technologies to make a website come alive is an exciting process and this is exactly what Ridgian did with one of their clients who wanted a BI solution integrated with mapping technology. Blending a mix of SharePoint/Silverlight/Bing Maps/PRISM Framework/Analysis Services/Reporting Services/Performance Point Server together to produce a stunning set of visuals for the users to work with. This solution is now a flagship system for the client who themselves plan to 'sell' their services through it and to expand it into all areas of their organisation.



In this session Dave will discuss the how using the Silverlight PRISM framework, his team integrated multiple data sources and third party components to create dynamic, intuitive and informative dashboards hosted on the Sharepoint  platform.

The .Net framework provides a rich set of collection classes, but how much do you really know about them? In this presentation we'll take a deep dive into the .Net 4.0 collection classes and examine which are best for what scenario and why. By the end of the presentation, you'll no longer be happy just reaching for the same old collection you always had before. Instead, you'll be armed with the information required to pick the best collection for your needs.

A practical example of how a mobile app...

"I have yet to find a single ASP.NET application that could not benefit from using caching"
ScottGu

Distributed caching allows you to spread a logical cache over a number of physical servers; this has benefits for scalability and availability. In this session we'll look at the distributed caching features of Windows Server AppFabric (the project formerly known as Velocity). We'll examine the two concurrency models provided by AppFabric for handling multiple servers updating the same cached data, and we'll look at how to increase the findability of your cached objects by using the tagging API in AppFabric. We'll also look at how to use AppFabric as an ASP.NET session state provider to share your sessions across your server farm.

If you're doing ASP.NET on multiple servers, this is a must-see session!

In the early days of C# there was virtually a 1-1 mapping between C# and IL. Much has changed since C# 1, the developer is encouraged to simply describe their intent and the compiler builds the appropriate code. This talk will dive under the hood and show how various C# features like iterator methods, anonymous methods, extension methods and dynamic all result in code gen by the C# compiler

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. 

Not many WPF/Silverlight developers are using Expression Blend yet; but those that are, couldn't do without it...

In this fast-paced talk and demonstration I will be showing how to use Blend in your everyday design and development tasks to rapidly create visually engaging User Interfaces and controls, and dramatically increase your productivity in building WPF/Silverlight front-ends.

We will cover real-world practical tasks such as: How to use the Blend environment, access key functionality, and use the different types of controls; Create and manage Resources and resource dictionaries within Blend; Create, edit, and apply Styles and Control Templates to different controls; Bind controls to sample and runtime ViewModel data and Commands; Make your applications stand out with Animations, Visual States, Effects, Fluid Layouts, and Behaviors; and some random tips and techniques I've learnt along the way.

While the presentation is targeted at developers with WPF/Silverlight experience who have not yet gotten to grips with Blend, if you're new to WPF/SL it will be a great introduction, and if you're familiar with Blend already then hopefully you will pick up something new.

Developers and managers generally don't understand each other. Developers know the arcane languages of machines and are motivated by inexplicable forces. Managers seem to spend half their time in meetings and the other half emailing each other Word documents and Excel spreadsheets. The result is that both sides end up frustrated, feeling that the other is stopping them from doing their job to the best of their ability.

In this talk, I will share some of the things I've learned in 20 years of being managed, including:

• How to get the PC you want, with the two big monitors and a decent CPU.
• Also, how to get extra software, training, and even sent to conferences.
• How to adopt best practices, like TDD, pairing and daily stand-ups even though your manager doesn't know what they are, and probably doesn't care.
• How to earn the respect of people who seem to actively like wearing suits.
• Maybe, possibly, how to respect them just a little bit.

CSS has a lot of the same problems that application code has but none of the language features that help us keep out of trouble. Start writing anything complicated and you end up with problems like dependencies, cohesiveness and creating the right abstractions. It's pretty easy to end up with CSS that is impossible to predict unless you understand it all. I'm going to tell the tale of my team's journey to write CSS that is flexible, easy to understand and easy to change. 

At PDC10 in October, Microsoft announced an update to the Sync Framework. Its one heck of an update though, adding a load of functionality to make sync'ing to Silverlight, Windows Phone 7 clients so much easier, including built in classes for oData formats, particuarly moving just about all of the processing off into the service side, enabling the client to be a slim as possible. We'll take a look at this new sync stuff, and its new tooling to see how it can significantly improved the user experience when a network is not available, without adding a load of work to the developer.

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 the mainstream .NET languages tomorrow. The session uses many examples to give you a good general overview of F#.

It should come as no surprise that Ruby is a dynamic language but do you know how to use this to you advantage. In this talk we will look at how to use Ruby’s dynamic nature to keep you code DRY, write less code and make your code easier to maintain. As a final example we will see how to use these same tricks how to create a simple DSL.

In May 2010 I changed jobs, leaving the land of .NET to the world of Ruby on Rails. In this talk I will go over what I found easy, hard or just completely misunderstood when starting with Ruby and Rails. While focusing on my experiences we will also look at the differences between .NET development and Ruby development.