| |
Tracks 1–6
DevWeek |
Track 7 & Track 8
SQL Server DevCon |
9.30 |
TRACK 1
Understanding thread synchronization – Part 1
Jeffrey Richter
This talk will explain the mindset behind proper thread synchronization. It will first cover the primitive thread synchronization constructs including volatile memory access, interlocked APIs, events and semaphores. We will go into the pros and cons of each. Then, we will discuss the various hybrid thread synchronization constructs including mutual-exclusive locks, reader-writer locks, and various new locks that are introduced in .NET 4.0. Jeff will also explain his own lock, the ReaderWriterGate, which Microsoft purchased the patent rights to.
TRACK 2
Years of .NET performance experience in 90 minutes
Anders Aaltonen & James Belsey
Programming .NET applications that are performance sensitive brings different problems from normal programming. Figuring out performance bottlenecks can take time, thankfully explaining them does not. For the last 9 years we have been building application components for apps that handle ticking data in .NET. In this talk we will present the hot-spots that we have discovered including explanations of why the problems occur. We will also explain how to write code that doesn’t suffer from these performance problems.
TRACK 3
A lap around Silverlight 4 – Part 1
Dave Wheeler
Silverlight has come a long way since its initial launch. With features such as COM Interop, internal navigation, advanced data binding and validation, behaviors and visual states, it can be hard to know how to put them all together. And then you have to consider PRISM, MEF, Expression Blend, and a whole host of other pieces as well.
In this demo-only talk, you’ll learn how to bring all of these technologies together as we start to build a representative Silverlight application based on the core ideals of Silverlight. Think of this talk as practical guidance on how to bring the many pieces of the Silverlight puzzle together to make a whole application. It’s not just a lap: it’s a practical, how-to-put-it-all-together lap.
TRACK 4
Improving quality with an automated build process
Simon Brown
This session will look at the development processes in use for an ASP.NET application where quality and consistency have a direct effect on the reputation of the organisation. We’ll look at: Subversion and our use of code branches to manage release complexity; Visual Studio and the add-ins we use on a daily basis; NUnit and our strategies for achieving over 90% code coverage through a combination of automated unit, integration and load testing; NAnt and how it allows us to build, test and release code from any of our development branches in an automated and repeatable way; CruiseControl.NET and how it performs continuous integration and testing on all of our development branches.
TRACK 5
Maximize reuse in your ASP.NET web sites
Robert Boedigheimer
Do you find yourself or coworkers “reinventing the wheel” on each web site you create? Learn ways to share web site assets such as style sheets, JavaScript, and images as well as code to save time, improve quality, and reduce maintenance costs. Learn techniques to increase reuse for a single web site and between web sites. Discover how to create shared assemblies in the GAC and how publisher policy files can be used to specify which version existing applications should use. HttpModules are another great technique for using consistent code such as error handling and logging across a series of web sites. Nobody wants 10 copies of code that are “almost the same” in various web sites, learn how to write code once and use it everywhere.
TRACK 6
Objects of value
Kevlin Henney
Objects do not live in a free society: they exist for a purpose; they are not created with equal rights; they should not aspire to equality. What this means in practice is that objects live in a class-ridden society where each class serves a different role in the program as a whole. One category of object in need of attention and liberation is for representing domain values.
Values are fine-grained and informational. They are inherent in the problem domain, but are often flattened into little more than plain integers and strings in the implementation, weakening the correspondence of the code to the situation it addresses. When it comes to identifying and implementing value objects, there is a great deal more to be taken into consideration than can reasonably fitted into a single pattern or .NET type. This talk looks at the practices and concepts that surround values in both C# and other languages.
|
TRACK 7
LINQ to SQL tricks and tips
Jim Wooley
You’ve seen how to drag tables onto a designer and get an instant data tier. Many applications need to go beyond the basic implementation. In this interactive presentation you’ll see some of the more advanced options LINQ to SQL provides to offer mapping alternatives, concurrency, use of stored procedures, inheritance, and stateless context management. In the end, you will leave with more tricks and tips to add to your LINQ toolbox. If you’ve chosen to use LINQ to SQL as your data access platform, this will be an opportunity to ask your real-life questions.
TRACK 8
Problem solving with the ROW_NUMBER function
Itzik Ben-Gan
The ROW_NUMBER function and the OVER clause it is based on are profound language elements that enable elegant and efficient solutions to a wide variety of querying problems. This session describes the design of the OVER clause, and specifically the ROW_NUMBER function, and demonstrates using the function to solve practical problems.
|
11.00 |
Coffee Break |
11.30 |
TRACK 1
Understanding thread synchronization – Part 2
Jeffrey Richter
This is the second part of the two-part talk detailed above.
TRACK 2
Functional programming in F#
Oliver Sturm
F# is a multi-paradigm language, but its syntax heritage comes from a functional world. Functional Programming is one of the main benefits that F# brings to the .NET platform. It encompasses many distinctive approaches and techniques, and this session provides an introduction to some of them, including the use of higher order functions, recursions and continuations, functional precomputation and memoization. The session requires a good understanding of F# foundations and syntax.
TRACK 3
A lap around Silverlight 4 – Part 2
Dave Wheeler
Your whistle-stop tour of the Silverlight universe continues, as we carry on building a small, but significant, Silverlight application. Yes, it will be using PRISM (and maybe MEF). Yes, it will have data binding, printing, graphing and a cool, slick visual appearance. Yes, it will run in and out of the browser. And yes, it will have unit testing, mocked objects and other “real world” features and practices coming out of its ears.
No slides. Only one, compelling, end-to-end demo of how to build a complex Silverlight Line of Business (LOB) application using all the best bits of Silverlight 3/4.
TRACK 4
Migrating from LINQ to SQL to the Entity Framework
Jim Wooley
With 3.5 SP1, Microsoft released two competing technologies to provide Object Relationship Mapping strategies over data – LINQ to SQL and the Entity Framework. Microsoft has indicated that future enhancement efforts will be directed toward the Entity Framework. As a result, people who built applications over LINQ to SQL are faced with the challenge of moving them over. We will explore the similarity and differences between the two technologies to help identify times when you should and should not migrate existing code bases. We’ll focus on the common pitfalls that developers need to be aware of when moving between the technologies. We’ll also look at architectural options you can make to make migration less painful, and at some of the functionality scheduled to be included in future versions of the Entity Framework which may influence decisions on making migrations.
TRACK 5
Attack and defence: securing ASP.NET applications
Keith Brown
Building secure ASP.NET applications involves much more than calling security APIs. It takes careful design that considers threats and applies countermeasures that solve real problems. It takes a development team that knows how to write bulletproof code, with the foresight and funding to review that code and eradicate security flaws before they can be exploited. Ultimately, it takes education and a good process. This talk will introduce you to many resources: guidelines for threat modeling ASP.NET applications, how-tos for eliminating common security vulnerabilities, and many others. You’ll find that even a small shop can afford to build security into the software development lifecycle.
TRACK 6
Programming with GUTs: writing Good Unit Tests
Kevlin Henney
These days testing is considered sexy for programmers. Who’d have thought it? But there is a lot more to effective programmer testing than the fashionable donning of a unit-testing framework: writing Good Unit Tests (GUTs) involves (a lot) more than knowledge of assertion syntax.
Testing represents a form of communication, with multiple levels and forms of feedback, not just basic defect detection. Effective unit testing requires an understanding of the forms of feedback and communication offered by tests, and what styles encourage or discourage such qualities.
What style of test partitioning is most common, and yet scales poorly and is ineffective at properly expressing the behaviour of a class or component? What styles, tricks and tips can be used to make tests more specification-like and scalable? This session uses C# and NUnit to examine what it takes to program with GUTs.
|
TRACK 7
Car crash queries, debugging, and resolving why DB performance suddenly hits the floor
Simon Sabin
We’ve all had an app that works fine but then suddenly starts to perform really badly. The DBA is probably blaming the Dev for writing shoddy SQL and the Dev is blaming the DBA for not maintaining the database properly. You probably recompiled queries, added indexes, updated statistics and maybe rebooted the server which might or might not have solved the problem.
This session is focused on why the database decides to do things that result in really bad performance. We’ll look at what causes these problems so that you can stop them happening in the future, or at least know what to do when it happens again.
After this session you will be able to (a) debug performance problems to find what queries are causing the problems, (b) diagnose why the query is performing badly, and (c) know how to resolve the different problems that can cause a query to run slowly.
TRACK 8
Minimally logged inserts and other data modification enhancements in SQL Server 2008
Itzik Ben-Gan
SQL Server 2008 enhances support for minimally logged inserts. This session will introduce the different insert methods that can benefit from minimal logging, and the enhancements in SQL Server 2008 allowing new insert scenarios that can benefit from minimal logging. This session will also cover other modification related enhancements like the enhanced VALUES clause, compound assignment operators, and the new MERGE statement.
|
13.00 |
Lunch |
14.00 |
TRACK 1
Building dynamically extensible applications and components
Jeffrey Richter
Today, more and more applications are being implemented as small shells that compose their features by loading separate components implemented by various companies. In this talk, you will learn how to build applications that can be extended with other components discovered at runtime. First, you’ll learn how to use AppDomains which provide many features such as assembly unloading, security sand-boxing, and configuration settings. Then, you’ll learn how to use reflection to dynamically load types and create objects in another AppDomain. Finally, we’ll focus on how to get the host objects to communicate efficiently with the add-in objects. This talk will also address issues related to versioning of the host and add-in components.
TRACK 2
The problem with change – immutable data
Oliver Sturm
Mutability of data is the source of much trouble for programmers who look for bugs in computer programs, or who simply want to create a stable testing environment with dependable, reproducible results. But using data that never changes is certainly possible – even in C#. This session provides an overview of the advantages as well as a practical introduction.
TRACK 3
Advanced WPF: making it perform
Dave Wheeler
So you’ve created the most beautiful, heavily data-bound, WPF application in the world. You’ve introduced animations and subtle opacity effects. You’ve used M-V-VM.
But now you’re wondering why it takes a minute or two to load the UI with some simple data?
This talk focuses entirely on WPF performance: the bad things to avoid; the good practices to follow; and most especially, using the various profiling and performance toolkits to work out what’s not working so that you can fix it.
Intensely practical, this session assumes that you’re already familiar with WPF, and now want to know how to make it fly.
TRACK 4
Patterns dartboard
Andy Clymer & Kevin Jones
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!
TRACK 5
Single Sign-On for ASP.NET applications
Dominick Baier
Single Sign-On is often considered the “holy grail” of authentication. Ranging from ASP.NET builtin features like Windows and Forms authentication to specialized protocols like OpenID or WS-Federation, ASP.NET developers have a lot of choices to implement this feature. As always every approach has its benefits and limitations. This talk takes a close look at the different options and where and how they can be applied.
TRACK 6
TDD by example
Neal Ford
It’s hard getting started with Test-driven Development – it seems like the world conspires against it. This session provides a gentle introduction to TDD, starting with a problem from scratch and building the solution bottom-up, using tests to help guide the design. I evolve the tests + code every step of the way, showing not only TDD techniques but the flow of coding when doing TDD.
|
TRACK 7
Building an application for Windows Azure & SQL Azure
Eric Nelson
In this session we will build an application that takes advantage of many of the features available in Windows Azure and SQL Azure and look at the implications of how we store data when we build applications deployed in the Cloud. We will cover “code near” vs “code far”, relational vs none relational, blobs, queues and more.
TRACK 8
Essential BI for developers – Part 1
Javier Loria
Are you or your developer team tired of building countless reports? Are you trying to build more intelligent applications? Have report queries taken control of your servers? If so, you may benefit from this session. We will examine how developers are incorporating Business Intelligence technologies into their applications. Developers are using BI to enhance the reporting capabilities of applications, to provide an analytical framework to analyze business processes and to ensure that the infrastructure will scale appropriately when report queries increase. First we’ll show how to use SQL Integration Services to validate, clean, and transform data. Secondly, we’ll use Analysis Services to create a data store that can resolve analytical queries. Finally, we will use Reporting Services to create an information distribution framework where users may create on-demand reports.
|
15.30 |
Coffee Break |
16.00 |
TRACK 1
What’s new in Managed Languages
Jim Wooley
The next version of Visual Studio will bring a number of enhancements that will reduce the amount of code you need to write and maintain. We’ll show you how to use the following technologies in the next release of Visual Studio: Auto Implemented Properties, Implicit Line Continuation, Statement and Multi-Line Lambda Expressions, Parallel extensions to the .NET Framework, Dynamic Language Interop, Co- and Contra-Variance, and Programming office without requiring dependencies on the Primary Interop Assemblies. In the process we will also show how Visual Studio 2010 allows us to generate code based on our usage to enable test first development models.
TRACK 2
Is the free lunch back?
Andrew Clymer
Herb Sutter famously coined the phrase “the free lunch is over” back in 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 parallelizing algorithms through the use of parallel constructs like Parallel.For, and Parallel 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.
TRACK 3
Get a whiff of WIF!
Keith Brown
The Windows Identity Foundation (WIF) makes it easy for web applications and services to use the modern, claims-based model of identity. This model allows you to factor authentication and many authorization decisions out of your applications and into a central identity service. This model makes it much easier to achieve Internet-friendly single sign on. It also makes it easier for your application to receive richer identity information, and paves the way for identity federation, should you ever need to integrate with another organization or another platform (Java, for example).
TRACK 4
A developer’s guide to load testing
Simon Brown
Load testing is an often forgotten and seemingly difficult task that many people shy away from doing. It doesn’t have to be this way though, with a basic level of load testing often enough to give you confidence that you’ve satisfied your performance and scalability requirements. This session will look at load testing a website from a developer’s perspective. We’ll look at the difference between load testing, stress testing and soak testing along with a hands-on demonstration of an open source load testing tool that you can use to get started. If you’re building websites in Java, .NET, PHP or indeed any other programming language, this session will show you how easy it is to load test your website.
Audience: Developers of all levels.
TRACK 5
Using the Microsoft AJAX Library
Robert Boedigheimer
Did you know Microsoft has provided a client library that abstracts away differences in client Javascript libraries in browsers? The library extends Javascript to appear to support features like inheritance, provides additional functionality for existing types, and provides a consistent event model. Learn how the library simplifies client development and shields the developer from browser idiosyncrasies. See how to invoke AJAX Page Methods and Web Services to contact the server from the client, and techniques to increase the security of such calls. Review how the AJAX Control Toolkit uses the AJAX Library, and how it can be used by non-ASP.NET web sites.
TRACK 6
A practical guide to use cases
Kevlin Henney
Use cases are seen by many as being a useful technique for gathering and organising requirements. However, there are many limitations to the way that they are commonly applied, including the overuse of UML use case diagrams, the use of sequence diagrams to describe use cases, and verbose use case forms. This session focuses on a more streamlined and practical approach to using and documenting use cases.
Use cases also have a great deal more to offer than just requirements capture. In conjunction with an assessment of business priorities, technical complexity and risk, use cases can be used to drive the development process itself. This session also describes how use cases can be used in an agile development lifecycle.
|
TRACK 7
T-SQL enhancements in SQL Server 2008
Simon Sabin
The work Microsoft started with in SQL Server 2005 to improve the T-SQL language has continued in SQL Server 2008. SQL Server 2008 introduces some very, very exciting new T-SQL language features. These new features not only make life easier for developers, but they help with performance as well. In this session we will take a closer look at some of the new enhancements and see what they can do for us.
Pre-requisites: T-SQL knowledge
TRACK 8
Essential BI for developers – Part 2
Javier Loria
This is the second part of the two-part talk detailed above.
|
17.30 |
Close |
|
