Baking a great Silverlight App: A recipe for successful designer-developer collaboration
Nick Harewood
In order to make the most of a User-Experience focussed platform like Silverlight, we need to adopt a design-led development process. To achieve this successfully requires close communication and collaboration between designers and developers. We have the tool in Expression Blend, but how do we best utilise it to ensure the end solution remains true to the vision?
Find out some of the best practice and tips of complex Silverlight application development, learn how to avoid the pitfalls and enable designers to best leverage this powerful toolset for a great user experience.
A voyage to functional heaven
James Millar
Imagine a world where not everything is an object. Where problems can be solved with minimal code in a succinct and frankly stylish manner. This is not a fantasy, this is F# and its shipping soon with Visual Studio 2010. Come and dive in with me as I guide you through the language and show you how you can integrate this fabulous language into your existing code base.
Don't be passive, be Reactive
Chris Alcock
This session will introduce the reactive style of programming using the Microsoft Research Reactive Extensions (Rx) projects for both JavaScript and C#, showing how Reactive programming using Observable collections can make your applications simpler to understand at the code level, more responsive for your users, and how the Reactive Extensions fit in with familiar concepts such as jQuery, the HTML DOM, LINQ, etc.
Debugging in the production environment using Windbg
Chris Alcock
Developers never knowingly release bugs into production, however sometimes these issues creep through, resulting in bad performance and errors.
This session aims to provide you with an introduction to using the Windbg Debugger to investigate application issues which may once your application is up and running in production, focusing on using memory dumps and the SOS extension to identifying what is going on in Managed .NET multi-threaded applications, find performance problems, and examining the state held in the application.
NLog - Getting the best from your logs
Andy Gibson
Logging, it is not a very interesting thing to have to add to an application but it can be a critical tool in diagnosing and fixing bugs both during development and post-launch. .NET has a number of logging frameworks but NLog has some very good features to bring to the table and this session will show you how to harness the power of the little logging framework that could and bring it to your own application. NLog can be used in a great number of scenarios ranging from ASP.NET deployment through to server monitoring and desktop application feedback.
This session will introduce you to NLog before showing you through live examples the main features of the framework and how you can use them in your own .NET development.
May the Silverlight 4's be with you
Richard Costall
In this demo packed session, Richard Costall will take you through the new features in Silverlight 4. We'll see Browser controls, Notifications, Elevated Privileges, and much much more in this'coming of age' release of Silverlight, all delivered in Richard's unique and entertaining style.
Silverlight DataBinding
Richard Costall
Databinding is quite often overlooked and often misunderstood. In this session Richard will give an overview of databinding in Silverlight , covering binding to objects, collections, using converters and commanding.
Contractual Obligations: Getting up and running with Code Contracts
Barry Carr
Code Contracts is Microsoft's implementation of Programming by Contract for .NET (also known as Contract Programming, or Contract-First development). Code Contracts are a way of adding executable specification documentation to your code; they can also work hand-in-hand with your unit tests. All-in-all, the aim of Code Contracts is to improve the quality and reliability of your software.
With Code Contracts you can: specify a method's pre-requisites (pre-conditions) and what it guarantees to do for it's caller (post-conditions); you can also specify what conditions must always be in-place throughout the the lifetime of an object (object-invariants). Code Contract conditions can be tested at runtime and, if you're using Team System, they can also be analysed and tested statically after your application has compiled. Using the features of code contracts in conjunction with your unit tests can help you find potential problems in your code sooner.
Code Contracts will be part of .NET 4.0 and are also available for .NET 3.5; they're language agnostic and integrate into Visual Studio (08 & 10).
The aim of this session is to show you how to write code contracts: method pre and post condtions along with object-invariants and we'll look at how Code Contracts work. In addition, we'll also be looking at using Code Contracts with TDD and how to use Contracts with Interfaces.
Microsoft Surface
Kris Athi
With the recent public release of the Microsoft Surface SDK, this session aims to introduce you, the developer, to this exciting new platform. We will explore a little bit of history behind this platform before delving deep into the capabilities that exist under the hood of the device.
We will then move on to explore the application development architecture and how you can leverage your existing skills with WPF or XNA to create compelling new user experiences on the device. By the end of the session, I hope you will see how this platform offers limitless new opportunities that will provide something never experienced by end users...and that it really isn’t just a big coffee table :)
Azure Table Service – Getting creative with Microsoft's NoSQL datastore
Mark Rendle
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.
Functional Alchemy - 10 tricks to keep your C# DRY
Mark Rendle
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.
Using the new Developer and Test features of VS 2010 to track down and fix bugs
Richard Fennell
How often do you find that bugs are reported in testing that are hard to reproduce in development? With Visual Studio 2010 there are a whole range of tools to assist in this process. In this demo lead session I will show an end to end demo of:
• Creating an automated build
• Defining and running manual tests in Microsoft Test Manager
• Logging bugs in TFS that include debug information such as videos and Intellitrace generated by the tester
• Fixing the bug based upon the information stored by the system to aid the debugging process
Basics of NHibernate
Colin Gemmell
NHibernate is one of the most mature ORM’s in the .Net stack. In this talk we will look why you would want to use an ORM in your project and the minimum you will need to get a project up and running with NHibernate. Using the classic XML mappings you will see how to map your entities to the database and preform basic CRUD work against the database.
Inversion Of Control with Castle Windsor
Colin Gemmell
An IOC container can be one of the most useful and powerful tools in a enterprise development. Castle Windsor is one of the most mature of these IOC frameworks and in this talk we will look at the principles behind using an IOC, how to configure Castle Windsor, and how to integrate it into several different project types.
Windows Phone: Why you should care and how to get started
Matt Lacey
Microsoft have just launched Windows Phone 7 Series. But what does this mean for you? Why should you care if you've never developed applications for phones before? And how do you get started when you do want to develop for a Windows Phone?
This session will attempt to convince you that understanding mobile development is useful for all developers and then demonstrate how to create an application for a Windows Phone 7 Series device.
Write less, but better, code with AOP & PostSharp
Matt Lacey
PostSharp is an Aspect-Oriented programming framework that will allow you to reduce the amount of code you need to write. It will also make the the code you do write cleaner, simpler and easier to support & maintain. This session will provide an introduction to using PostSharp to save time and therefore money in your development.
Everything in the Kitchen, Syncd
John Price
With more and more PC devices appearing in the marketplace, we have more and more data that needs to be kept up to date, Calendars and contact lists come to mind and is readily dealt with by applications such as Outlook and Exchange, but what about data in your own applications? Does your application really need a constant connection to its data? How can you provide this level of disconnectability (if thats a real word) in your own software? ADO.NET Sync Services, thats how!
This session will look at the ADO.NET Sync Service framework and, demo gods permitting, we'll have a go at building an app that can work just as well with or without its database server.
What's New in ASP.NET MVC 2.0
Andy Gibson
ASP.NET MVC has been making waves over the past 2 years within the ASP.NET community and quite rightly so with features such as promoting separation of concerns, strongly typed views and a great routing system but it doesn't stop there. ASP.NET MVC 2.0 is now publicly available and is also being shipped with Visual Studio 2010 but what new features have been brought to the table? What has changed? And most importantly, how will you be affected by upgrading from 1.0?
This session will bring you up to speed with all the information you need to know delivered through slides and more interestingly, live demos. Topics covered include (but not limited to)
o Areas o Model-Validator Providers
o Optional URL Parameters
o Template / HTML Helper improvements
o Additions and updates to MVC Attributes
o Visual Studio integration improvements
o Breaking changes from MVC 1.0
o To upgrade or not to upgrade (or simply, Advice)
Exception Driven Development
Phil Winstanley
"If you're waiting around for users to tell you about problems with your website or application, you're only seeing a tiny fraction of all the problems that are actually occurring. The proverbial tip of the iceberg."
In this session we'll explore how to detect and hunt down exceptions in live applications. You'll learn about .NET and JavaScript exception handling and more about Exceptions than you'll have thought possible!
We've come up with a series of methodologies and practices that can help you take your development and support to the next level.
It'll be an ... Exceptional ... session. (Sorry).
Crap Code and the Disasters it Causes
Phil Winstanley
There you sit, it's a Wednesday morning and before you is the code another developer has left you. At first you can't believe your eyes, perhaps you misread it... No ... He really did write it like that ... Crap Code.
In this session we'll explore Crap Code that we've come across in the past few years of Consulting, the problems it causes and the solutions to the idiocy of other developers.
You'll laugh, you'll cry - but most of all, you'll come out of the session realising you're a pretty damn good developer.
Get going with jQuery
George Adamson
A fast paced 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 boring slides!
A great session for those fairly new to jQuery or not fully aware of what it can do for you. We also dive into some advanced usage and best practices.
AJAX with jQuery
George Adamson
Getting started on AJAX with jQuery: An introduction to AJAX and it's benefits; how to use jQuery to handle your AJAX; 'hijaxing' and progressive enhancement with jQuery and AJAX; solutions to get around the 'Same Domain Policy'. We'll work through a bunch of examples to post and get data from various sources.
This session keeps moving at quite a rate. We begin with 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 fine.
Cross browser CSS
George Adamson
"Well it looks fine in my browser..."
Front end development can be a right old pickle. Some bits work in one browser, then the same CSS looks screwy in another. For many of us, CSS is a weird voodoo world of DIVs and floats and stuff. Ideally we'd pass that styling job over to our CSS/UI colleagues but sometimes we just cannot escape it.
This session demonstrates many of the differences between browsers and provides ways to solve them. All those terms you hear, such as "Box model" and "doc type" and "float". We'll find out what they are and why they make us grumpy.
We'll also look at some best practices and suggest ways to make our html easier to style.
Having fun with Functional Programming in F# with VS2010
Ebru Cucen
This session will be an introductory session for F#, if you have not had the chance to look at it. I will talk about the essence of functional programming, and the keywords for F#. We will get hands dirty and code in F# by the end of the session.
Command Query Responsibility Segregation apporaches to System Design
Neil Robbins
The Command-Query Responsibility Segregation (CQRS) pattern has recently been getting a lot of deserved attention. In short, it requires separate command and query paths through a system. Through this CQRS promises simple yet powerful designs and codebases. CQRS approaches can also help leverage other patterns such as Event Sourcing and Pub-Sub to open up some very interesting opportunities.
I have been involved now in the development of two systems which seek to follow this pattern, one in insurance & one in public examinations. My experience, and that of my colleagues, has been that the systems built following this pattern have been more flexible, simpler, and quicker to develop than had been achieved following more conventional ActiveRecord/DDD approaches.
This talk will introduce you to the CQRS approach, what it means to the design of your systems, how it builds on DDD (domain driven design, not the conference :), when you might (or might not) want to use it, and bootstrap you to begin using this approach within your own contexts.
NoSQL and CouchDB
Neil Robbins
For many years now RDBMS tech has pretty much had a monopoly on the world of datastores. In the last few years though a brave new world of non-relational databases has been gaining increasing popularity and come together as a NoSql movement.
This talk will be largely based on the one I delivered at DDD 8, but this time with a shorter intro to the NoSQL space, and a greater focus on CouchDB allowing time to show and explain MapReduce and replication. So even if you saw it before you'll get a new experience!
It'll be an introductory talk, so if you're already a master of the field don't expect to learn much. But if you're looking to understand the problems that the NoSQL solutions seek to address, why a relation approach might not always be the one you want, and to get bootstrapped so you can get working with CouchDB quickly then this talk will be for you.
Introduction to PRISM
John McLoughlin
PRISM is the latest incarnation of the Composite Application Guidance from the MS Patterns and Practices team. The guidance allows you to build extensible application quickly and easily in either WPF or Silverlight. In this session I'll show you how easy it is to build a WPF application and then extend it with PRISM.
Introduction to WF 4.0
John McLoughlin
WF 4.0 was announced at PDC 08, and includes some very sexy new features. We'll take a spin through some of those new features and see how WF has evolved.
Unity & the fabled IoC
John McLoughlin
Unity is the Microsoft Patterns and Practices offering for an Inversion of Control (or Dependency Injection) Container. We're have a whistle stop tour of the concept of Inversion of Control, where IoC containers fit into the picture and a look at some real world examples.
The real world experience of a startup using and fighting with Azure
Ross Scott
We've seen the demos, written the "Hello World" but is it really a good idea? This session will take you through the first 3 months of a new startup developing on the Azure platform. The startup exists for one reason: to make a profit. So this will be the driving factor throughout the session. Areas of Azure covered will be:
• Cost driven development, a new way of thinking.
• Data storage, should I go with the easy option or change my relational mindset?
• Lessons learnt.
• What's it actually going to cost me?
• A few tips and tricks
Lessons Learned in Unit testing
Andrea Magnorsky
Unit testing is hard to learn, will be presenting what I learned so far with an example going through the thinking process on writing tests (first), and after formalizing those concepts. The goal is to understand:
- Unit testing vocabulary
- Mocks and Stubs
- Test Smells
The session doesn't include comparison between unit testing or mocking frameworks.
Clean User Interfaces with ASP.NET WebForms
Dave Sussman
ASP.NET WebForms often gets denigrated for producing bad HTML, a fault that occurs if you stick with the default behaviour. However, with a small amount of customisation and knowledge of the ASP.NET server controls, you can create rich applications that have a clean and standards compliant user interface. This talk focuses not only how to break ASP.NET WebForms out of its mould, but also on why you shouldn't just accepts the defaults.
Once Upon A Time.....
Tom Quinn
The lines between developers and testers are becoming increasingly blurred (and rightly so) as agile adoption gathers pace. Learn how you can apply your development skills to produce a DSL for automated acceptance testing (using Story Teller and Selenium) and help the move away from the throw it over the wall culture.
Asp.Net UI Testing with Selenium
Nathan Gloyn
So you've got NUnit/MbUnit/XUnit etc for testing your logic classes but what can you use to test your UI? How can you add it to your normal test suites written in C# or VB.Net? This talk aims to show what you can do, the pitfalls and how best to utilise the tool.
So you want to try Scrum?
Nathan Gloyn
So what will scrum do for you? How can it help? In this presentation I aim to give an overview 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.
Learning the 'right' way
Daniel May
There are many different methods of learning how to develop, design and manage effectively, efficiently and do things in the 'right' way. This begs the question - what is the 'right' way? Is it via reading books, reading blogs, or not reading at all? Is it via pair-programming, code reviews, and how much does this affect the learning process?
In this session, Daniel May will be going over the common ways to learn a new language, pattern or aspect of development and design, and suggesting improvements and recommendations to these methods. Subjects covered will include learning from books including publication choices and recommendations, learning via pair-programming and code reviews, learning in the workplace with internships, official microsoft training (.NET) and much more.
Applied F#
Gary Short
By now you will have heard many introductory talks on the subject of F#, now it's time to take things a stage further. In this presentation we'll have look at how I use F#. We'll see examples of F# used to calculate values for some of the metrics that are important in my line of work. By the end of this session you will have a clearer understanding of how to use F# in your own projects.
Not Everything is an Object
Gary Short
We've all been trained to be OO programmers, universities have taught that way for years. OO development is most suited to those problems that can be described by hierarchies of related objects sending messages to one another and modelling state changes. However, not all problems can be described in this way, and with the advent of multi-core processors, we could be seeing the dying days of OO programming. In this presentation, I'll show you why OO programming is not the most suitable paradigm for solving all problems and why it certainly isn't the best paradigm for taking advantage of multi-core processors. Using real world examples, this presentation will go beyond the basic introduction to the functional programming paradigm and demonstrate those problems best solved using a functional approach, including those of concurrency. Examples in F#.
Credit Crunch Code - Time to Pay Back the Technical Debt
Gary Short
Technical debt is the cost of putting off good development practices. This debt, must be paid back to avoid the "interest payments" becoming crippling. This presentation will further define technical debt, before examining some anti-patterns and how to avoid them. We'll then look at how to put a financial cost on technical debt, and end by examining some measures to identify technical debt in a code base.
My Favourite Design Patterns
Gary Short
To achieve the best solution to a design problem requires expert knowledge. Expert knowledge takes time, collaboration and dedication to acquire. This session will enable you to leave having gleaned some of that expert knowledge from the speaker's 20 years in the software industry. We will define the term 'design pattern', explore its method of application, and we will work through some real-world and pan-industry examples that you can expect to encounter during the software development process.
The Need for Speed
Phil Pursglove
A Developer's Guide To Velocity Velocity is Microsoft's new distributed caching framework. In this session we'll look at why you might want a distributed cache, how to configure your applications (and servers!) to use it, and how to manage it when it goes live. We'll also explore some of the other features of Velocity, including concurrency and locking, tagging, building a highly-available cache, and how to integrate Velocity into ASP.NET's output caching mechanism.
So You Think You Know JavaScript
Kevin Jones
Javascript is an object oriented language but you wouldn't think so if you look at much of the JavaScript on many of the web pages in the world. If you've written JavaScript you must wonder, as I did, how to write code that is more maintainable. In this talk we will examine how to create objects in JavaScript; how to use inheritance; how to call base methods and how this all helps create better more maintainable code.
Design For Testing
Kevin Jones
Many developers now recognize the importance of unit testing, and either use Tes First or Test Driven development. However, many developers and architects are still struggling to come up with designs that enable easier testing of their applications. This talk will examine some common unit testing problems and use various unit testing patterns to solve those problems.
Testing ASP.Net MVC Applications
Kevin Jones
One of the primary advantages to using MVC.Net is to be able to test. So how do we do it? Testing models we know about, but what about testing controllers. In this talk we will take a simple application that uses is written in such a way as to be difficult to test and talk about the steps to enable testing. We will show how to use controller factories to create controllers and IoC to inject dependencies into the controller which will unable us to write tests.
Introduction to SOLID
Chris Canal
Robert Martin first brought together a number of existing OO principles to create SOLID a few years ago. Other platforms have been aware of them for awhile, but it took a moron by the name of Joel Spolsky to bring them the attention of the .Net masses. Since then, many people have been more maintainable software that reacts better to change on the .Net platform by taking them into consideration. In this session we will look into the advantages these guideline's bring and take an in-depth look at the advantages and disadvantages they can bring in a real world application.
Leveraging Convention Over Configuration
Chris Canal
Convention over Configutation was made popular by Rails and a number of OSS .Net projects taken advantage of the idea. In this session we will look at a number of these projects, and examine how you can take advantage of Convention over Configuration in your application.
Real World Application Development with Castle Windsor and ASP.NET MVC 2
Chris Canal
Castle Windsor offers more than an IoC container, offers a number of facilites that can reduce the amount of code required to implement things like Logging, NHibernate integration, AOP and more. In this session we will look at what Castle Windsor offers beyond the IoC container and look at building an application from File - New leveraging these tools.
Is the Free Lunch Back ?
Andy Clymer
A deep dive into Parallel.For, and ForEach....moving straight passed the standard trade show demos and examine the complexities of making loops scale. During this talk we will take a sequential for loop and try a variety of parallel loop implementations to finally produce a version that truly scales. At the end we will show that Parallel.For is not a simple replacement for a standard C# for loop as it is often cracked up to be. This session is aimed at those who have a good understanding of threading.
Patterns Dartboard
Andy Clymer
Imagine a (virtual) dartboard. That dartboard has a selection of patterns pinned to it. Members of the audience can throw darts at the dartboard. Where the darts hit will determine how the talk goes. The talk will be about patterns, although which ones it’s impossible to know – it’s up to you to choose what goes into the talk! Will it be MVC? Factory? Command? Your darts! Your choice!
The chaotic world of asynchronous programming with .NET 4
Andy Clymer
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 whirlwind tour of the new API, demonstrating how to implement a variety of asynchronous patterns utilising .NET 4 and Visual Studio 2010, and highlighting various gotchas that are simply inherent in asynchronous programming.
Exploring Software Transaction Memory in .Net
Steve Strong
In contrast to Axum (essentially a shared-nothing model), STM revolves around providing an easier approach to handling concurrency with shared state. Instead of the traditional (and error prone) approach of locks, STM provides the ability to mark a section of code as “transactional”, giving the Atomicity and Isolated properties of the ACID acronym. This session looks in detail at the usage of STM, covering areas such as:
• The Atomic block
• Commits, Rollbacks and Retries
• Failure atomicity
• Nested transactions
• Integration with System.Transaction
• Atomic Compatibility Contracts
• Suppression & Redirection
• Performance and Scalability
The session is aimed at the intermediate developer – a good understanding of basic threading principles and issues is required.
The Parallel Task Library in .Net 4.0
Steve Strong
Introduced with .Net 4.0, the Parallel Task Library gives a new approach to task-parallel programming. In this session we dive into the details of the library, looking at the various ways that it can be utilised. We will cover a number of areas, including:
• Data Parallelism, using Parallel.For and Parallel.ForEach
• Task Parallelism, using Parallel.Invoke and the Task class
• Exception Handling
• Cancellation
• Asynchronous continuation patterns
• PLinq
The session is aimed at the intermediate developer – a good understanding of basic threading principles is a requirement.
Overview of Concurrent Programming Techniques
Steve Strong
This talk gives an overview of some of the options available for concurrent programming on .Net. It examines the principles of concurrent programming and the reasons for adopting it, and also looks at the issues that such techniques introduce. Through the course of 60 frantic minutes, we will look at:
• The Parallel Task Library introduced in .Net 4.0, including PLinq
• The Axum language from Microsoft Research
• Software Transactional Memory, also from Microsoft Research
• CHESS, a tool for helping to locate concurrency issues
The session is aimed at the beginner / intermediate developer, or perhaps the seasoned expert that maybe hasn’t been active in this field. A basic understanding of processes and threads and the System.Threading namespace is a distinct advantage.
CHESS – Finding & Reproducing Heisenbugs in Concurrent Programs
Steve Strong
CHESS is a tool from Microsoft Research that aims to find and reproduce hard to locate concurrency bugs. It does so by repeatedly running tests, systematically enumerating how the various threads are interleaved on each run. When (if) errors occur, CHESS can also then re-run the specific interleaving that resulted in the error, massively simplifying the debugging effort. This session looks in detail at the usage of CHESS, covering areas such as:
• Common concurrency issues
• Sources of threading nondeterminism
• The CHESS scheduler
• CHESS within Visual Studio
• CHESS from the command line
• CHESS algorithms
The session is aimed at the intermediate developer – a good understanding of basic threading principles and issues is required.
A Dive into Axum
Steve Strong
Axum is a project from Microsoft Research that provides a new programming language to aid with the construction of highly concurrent systems. It is based on an actor model with immutable messaging over protocol-based channels. We will cover a number of areas, including:
• Agents
• Channels and Ports
• Request-Reply patterns
• Protocols
• Domain and State sharing
• Data Flow Networks
• Distribution
The session is aimed at the intermediate developer – a good understanding of basic threading principles will make the Axum model easier to understand.
A Whirlwind Tour through Workflow 4.0
Richard Blewett
Workflow 4.0 is a very different beast from earlier incarnations. Microsoft have rewritten it from the ground up and have simplified many complex areas and introduced some powerful new features such as Flowchart based workflow. This talk will take you through the highlights of workflow 4.0 and will show you why you should care about it – from building visual scripting functionality for your users to encapsulating business logic in a user friendly form to orchestrating complex services.
Building WCF services with Workflow 4.0
Richard Blewett
Clarity of processing and automated persistence make workflow a great tool for building WCF services – especially those that consume other services. This talk shows the power of workflow in the service world and demonstrates building rich processing with the data orientated correlation infrastructure
The WCF 4.0 Routing Service – A Powerful Box of Tricks
Richard Blewett
WCF has always supported a number of ways of exchanging messages: request/response, one-way and duplex. However, WCF 4.0 introduces a new component, the Routing Service, that provides out-of-the box support for multicast, failover and data dependent routing. This talk shows you how simple it is to bring complex messaging patterns to life with the Routing Service
Exploring Windows Live ID
Jimmy Skowronski
Microsoft Live ID evolved from Microsoft Passport and provides identity for myriad websites and applications. Every .NET developer has used it at least once to log on to Messenger, Channel9 or MSDN. Recently Live ID joined with Open ID which makes it even bigger and more important. In this session I will explore the basics of federated identity and show how you can benefit from Live ID in your websites and desktop applications.
T4 and how it can be used for code generation in Visual Studio 2008 / 2010
Rob Blackmore
T4 is the best kept secret in Visual Studio. In this session I will look at how it can be used to generate any type of code be it a class, T-SQL or even XAML!
Commercial Software Development - Writing Software Is Easy, Not Going Bust Is The Hard Bit
Liam Westley
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.
From Blend to Printed Page – Real World Printing with Silverlight
Joel Hammond-Turner
In this session you will see how the new Printing features of Silverlight 4 allow you to design for print using Microsoft Expression Blend, and be confident that your design will translate onto the printed page. Learn some of the tricks of printing with Silverlight, including an introduction to the Printing API, how to scale, position and paginate your content correctly on the page, and how to use the same XAML for both print and on-screen UI.
Business Connectivity Services and SharePoint 2010
Phill Duffy
An informative talk on the how, what and why of the Business Connectivity Services (BCS) and SharePoint 2010. The talk will give an introduction to BDC (the previous name of BCS in SharePoint 2007) , explain what issues the BDC was designed to address, demonstrations on how to configure a BCS Model to access Line-of-business data and then examples of how you can work with your business data within SharePoint.
The Real World Silverlight Development Experience
Ian Walker
This session will cover all aspects of the development of the public Silverlight based web site http://FromTheMalverns.com. Begininng with the background to the content on the site, how and why it came about moving through the technical aspects of preparing the content and finally how the site was put together to show the content in interesting and dynamic ways using Silverlight. Along the way I will also cover the following:
* Whats happening with Windows Mobile 7 development and Silverlight
* How to host a SIlverlight Application for free.
* Some options for getting web stats for a SIlverlight Application.
* Geocoding data then quickly displaying it in the web site.
SQL Injection Attacks and Tips on How to Prevent Them
Colin Mackay
In light of some recent events, such as the man who was convicted of stealing 130 million credit card details through a SQL Injection attack, it is imperative that developers understand what a SQL Injection Attack is, how they are carried out, and most importantly, how to defend your code against attack. In this talk Colin Mackay will demonstrate a SQL Injection Attack on an application in a controlled environment*. He’ll show you where the vulnerable code lies and what you can do to harden it. Although this talk uses C# as the application language and Microsoft SQL Server 2008 as the database engine many of the concepts and prevention mechanisms will apply to any application that accesses a database through SQL.