| |
Tracks 1–6
DevWeek |
Track 7 & Track 8
SQL Server DevCon |
09.30 |
TRACK 1
Generics, anonymous methods and iterators
Jeffrey Richter
In this talk, Jeff looks at the internals of some C# 2.0 features that programmers use every day. For generics, he’ll talk about all the changes that had to happen to the CLR and compilers to make them work. He’ll also go into how the CLR creates type objects of generic types and memory and performance issues when using generics with reference types versus value types. Constraints and the odd behaviours they exhibit will also be discussed. Then, we’ll go into anonymous methods, what the compiler lets you do and not do as well as how the compiler implements closures. Finally, we’ll discuss C# iterators and how collection classes use them to return their ordered set of values. Iterators are a very heavily used feature in making C# 3.0’s Language Integrated Query feature work, and iterators you create can integrate with LINQ.
TRACK 2
Getting started with .NET production debugging
Ingo Rammer
But… it used to work yesterday! In this newest version of his classic session, Ingo Rammer will introduce the hardcore and low-level tools used for production debugging of .NET applications. You’ll learn how to attack the nastiest bugs in your applications, how to look at what’s causing that grinding halt of your ASP.NET application and how to find the cause of that horrible memory leak in your Windows Forms application. Knowledge of production debugging tools like WinDbg and SOS is not only important for cases when you really don’t have access to Visual Studio and your source code, but these tools also reveal a lot more information than just the regular managed code debuggers.
TRACK 3
Cool graphics, hot code: ten visual effects to make you the envy of your peers
Jeff Prosise
Silverlight is known for amazing browser-based UIs, but great graphical effects don’t happen by accident. In this demo-laden session, Jeff presents reusable eye-candy effects complete with samples and code libraries that will have you building eye-popping UIs tomorrow. Guaranteed to make you the life of the next Silverlight party!
TRACK 4
Service virtualization
Aaron Skonnard
Service virtualization is the key to managing complexity and change in large, real-world SOA environments. The Managed Services Engine (MSE) is a service virtualization solution built on WCF and the Windows Server Platform developed by Microsoft Services. The MSE provides versioning, management, service enablement, and runtime policy enforcement. Recently, Microsoft made this valuable solution available to customers through CodePlex. This session introduces you to service virtualization, the MSE, and shows you how to get started today.
TRACK 5
Introduction to SharePoint 2010 for ASP.NET developers
Fritz Onion & Jon Fancey
SharePoint has emerged as one of the most common platforms for deploying Web applications, and for a good reason – it provides many higher-level building blocks for constructing web applications that would take literally years to develop by hand. The latest release, SharePoint 2010, comes with even more features, and is even friendlier to developers. However, ASP.NET developers coming to SharePoint for the first time are often frustrated by the fact that many development techniques they are accustomed to no longer apply, even though SharePoint is built on top of ASP.NET. This talk will introduce the practising ASP.NET developer to the SharePoint development environment and answer common questions like: How are requests routed? How do I customize a page layout? Where do I put resource files to make them accessible? Should I use Profile? How do I incorporate Ajax/jQuery into my pages?
TRACK 6
My boss said the word “Agile”. Now what?
Neal Ford
We’ve been set free from the waterfall. What next? This talk provides a pragmatic introduction to easing yourself into an agile methodology without frightening the livestock. I talk about first steps, how to handle common pitfalls, how to pace the introduction, and tons of other tips. This talk is designed for interactivity; bring your problems with Agile and we’ll see if we can fix them.
|
TRACK 7
Leveraging SQL Server CLR executables
William Vaughn
One of the most discussed features in SQL Server is its ability to execute CLR-based assemblies. This topic is especially important for DBAs concerned with developers’ use of CLR code as well as developers needing to perform operations beyond TSQL’s capabilities. While SQL Server has been able to execute non-TSQL code for some time, this session discusses how developers and DBAs can use Visual Studio BI tools to create, test, deploy, and debug CLR-based stored procedures, User-defined Types (UDTs), and User-Defined Functions (UDFs). We’ll discuss where this technology makes sense (and where it doesn’t) and how it’s implemented. The session walks through three examples: one that does not make sense for conversion but illustrates the development techniques, and two others that provide rich examples of the issues and techniques associated with writing CLR assemblies for SQL Server.
TRACK 8
Advanced T-SQL tips and tricks
Itzik Ben-Gan
This session covers advanced T-SQL tips and tricks. It will demonstrate how to solve common T-SQL problems elegantly and efficiently. The session will cover techniques in SQL Server 2005, and where relevant it will also cover techniques that involve new features and enhancements in SQL Server 2008. The purpose of the session is not only to learn tips and tricks, rather also to have some fun with T-SQL. This talk is aimed at SQL Server DBAs and developers with at least one year of experience with T-SQL. |
11.00 |
Coffee Break |
11.30 |
TRACK 1
Automatic memory management (the garbage collector)
Jeffrey Richter
The CLR manages the creation, lifetime, and destruction of all managed objects by way of the managed heap and its garbage collector. In this session, we’ll explain how the managed heap and the GC work. The difference between a reference counting GC and a reference tracking GC will be explained and why the CLR uses a reference tracking GC. The GC ensures that memory leaks do not occur, memory corruption does not occur, and also simplifies the .NET API due to the reduction of memory buffer negotiation. This session will also focus on features offered by the GC such as finalization and explicit object cleanup as well as techniques for improving performance.
TRACK 2
The tricks of production debugging
Ingo Rammer
WinDbg and SOS are great tools when it comes to production debugging, but without the right strategy and supporting tools, their use can be quite challenging. In this session, Ingo will show you updated and current versions of techniques and (free) tools which simplify your in-depth debugging work and will also introduce you to the new crash-dump debugging techniques in Visual Studio 2010.
TRACK 3
Can you keep a secret? The biggest little-known features in Silverlight
Jeff Prosise
So you think you know Silverlight. But how well do you really know Silverlight? Did you know, for example, that Silverlight 3 features two very different HTTP stacks and that one of them can be used to circumvent the most frustrating limitations of Silverlight networking? Did you know that ComboBoxes can be virtualized for high-performance? Or that the BCL now includes support for CPU metrics? Join the fun as Jeff takes you on a backstage tour of Silverlight and presents it in a way you’ve never seen it before.
TRACK 4
WCF 4: what’s new
Christian Weyer
The next milestone in distributed applications programming on the .NET platform is ahead. In .NET 4.0 WCF and WF will be totally complementary technologies. But it is worth looking at the new Windows Communication Foundation by itself, and shedding some light on the improved power of the number one communication framework in .NET. Christian Weyer demonstrates the innovations and new features in WCF, like new programming and configuration simplifications, routing, discovery, enhanced REST support and more.
TRACK 5
Web Forms vs. ASP.NET MVC
Dino Esposito
It risks becoming an endless debate: should you use ASP.NET Web Forms or the newest ASP.NET MVC to build your next application? The simple answer is that there’s no winner and no loser. The frameworks are functionally equivalent and just bring two different philosophies into ASP.NET development. So it is mostly a matter of preference, but it is also an architectural decision not to make with a light heart. In this session, we’ll compare and contrast the two frameworks from a number of different perspectives including reporting capabilities, data entry, AJAX, data binding, HTML, styling, and more.
TRACK 6
Why REST?
Aaron Skonnard
As REST continues to grow in popularity, it’s important to stop and ask yourself why REST? REST is by no means a silver bullet, but it does offer some advantages over traditional SOAP and WS-* architectures when it fits well into your scenario. There are also times when SOAP makes more sense because it offers features and capabilities that REST cannot provide. In the end, REST and SOAP are different architectural styles, each with their own pros and cons. Come and learn when to choose one over the other and why REST makes sense for many web services.
|
TRACK 7
Entity Framework in the NET Framework 4 and Visual Studio 2010
Eric Nelson
This session will take a detailed look at the new capabilities of the Entity Framework that will ship with Visual Studio 2010. The second release of the Entity Framework focuses on addressing two primary customer scenarios: Domain-Centric application development (TDD/DDD) and the traditional Data-Centric web application “Forms over Data”. This talk will include an in-depth feature overview, covering: N-Tier, T4 Templates, POCO, FKs, Mapping, Metadata, etc.
TRACK 8
Working with addresses and locations in SQL Server 2008
Greg Low
SQL Server 2008 introduced outstanding options for working with locations and addresses via the introduction of the spatial data types. These new types are useful for solving a variety of common business problems, not just for mapping people in white coats hidden in back rooms. In this session, Greg will show what is now possible with these new data types and provide examples of standard business problems that they can help solve. |
13.00 |
Lunch |
14.00 |
TRACK 1
Exception handling
Jeffrey Richter
Exception handling is an elegant and structured mechanism for reporting and recovering from errors in your software. In the .NET environment, exception handling is not just an option-it’s the only way to do error handling! In this session, we’ll describe how exception handling works in .NET, as well as successful design patterns for use in your software. You’ll learn how to apply exception handling to the various types of code that you write, from reusable components to application software. A large focus will be spent on best practices and guidelines so you learn how to use exceptions effectively and efficiently. Performance issues will also be addressed.
TRACK 2
Code contracts and design for testability
Dino Esposito
Testability depends on a number of attributes of the software. One of these attributes is the ability to observe the current state of the software being tested and the output it produces. Another point is making it clear the initial conditions under which a piece of software should run, and what are expected results. All together, these attributes form the software contract of a class method. The software contract is based on preconditions, postconditions, and invariants – abstract formulae to express the “conditions of service” of a method. How would you code a software contract? You can code it manually or, if you’re using the newest C#, you can use the Code Contract API. In this session, we’ll take a tour of the Code Contract API and see a number of examples of how to use it to implement testability in your classes.
TRACK 3
Dependency Properties: the critical technology
Dave Wheeler
“It’s a property, right. Why should I care?”
Dependency Properties (DPs) are possibly the most critical technology underpinning WPF and Silverlight, yet many developers glibly dismiss them without a thought. Without DPs, however, there would be no animation, data binding, attached behaviors, sensible layout mechanism and so on. This session takes a deep dive into DPs, examining coercion, performance, overriding and, most importantly, examining the differences between WPF and Silverlight.
You don’t need to be a WPF (or Silverlight) expert to attend this session; but if you want to be an expert, then it’s a must.
TRACK 4
.NET Service Bus: limitless communication with WCF & beyond
Christian Weyer
WCF-based applications are faced with several communication and connectivity obstacles in their daily life. Often secured connections are not allowed through firewalls and NAT devices at all. What to do if you need ubiquitous connectivity? Microsoft’s .NET Services Service Bus can be seen as the Swiss Army Knife of communication. Christian Weyer shows you how to build mighty cross-platform communication patterns like publish/subscribe – all in a safe manner, programmed with WCF or pure REST.
TRACK 5
Building RESTful services with ASP.NET MVC
Aaron Skonnard
The ASP.NET MVC framework provides an elegant model for building RESTful applications and services. This session will show you how you can use ASP.NET MVC to build sophisticated RESTful services that integrate with your ASP.NET applications.
TRACK 6
Real-world refactoring
Neal Ford
Refactoring is a fine academic exercise in the perfect world, but we don’t really live there. Even with the best intentions, projects build up technical debt and crufty bad things. This session covers refactoring in the real world, at both the atomic level (how to refactor towards composed method and the single level of abstraction principle) to larger project strategies for multi-day refactoring efforts. I also discuss refactoring the un-refactorable: databases, build files, and strategies for handling those methods that positively frighten you when you look at them. This talk provides practical strategies for real projects to effectively refactor all sorts of project artifacts.
|
TRACK 7
Report Builder 2.0 – a new beginning
William Vaughn
While my initial impression of Microsoft’s Report Builder was less than stellar, I think you’ll agree that the new version that shipped with SQL Server 2008 is a much better tool to build and manage SQL Server Reporting Services reports.
This session introduces developers, architects and managers to Report Builder 2.0. Is it perfect? Ah, not so much, but it does have a lot of promise. We’ll take a close look at the mechanisms used to create and customize new RDL reports, save, deploy and launch them and the issues you’ll likely encounter along the way. We’ll experiment with alternative data sources, parameters and expressions and see how far you can stray from the Reporting Services path. Before long your end-users will be using this newly designed tool to help them create their own reports – without having to call you on the phone every five minutes.
TRACK 8
Database security for developers
Javier Loria
There are many things developers need to know about security. By contrast, hackers only need to know one thing: what the developer missed. In this session we won’t teach you everything there is to know about security, but we will review the process of securing a SQL Server installation and the applications that use the server. Attendees will see how to take a layered approach to build security into real world applications and how to reduce an attacker chance of success. We will use tools and scripts that help you validate how exposed the system is.
|
15.30 |
Coffee Break |
16.00 |
TRACK 1
Are Singletons evil?
Andy Clymer & Kevin Jones
You’ve probably heard the comment that “Singletons are evil” and also the counter-argument that they are completely necessary. This talk will be take the form of a debate between the two presenters, one presenting the reason that Singletons are necessary and the other why they are evil. Along the way we will cover the Singleton pattern, unit testing, IoC, Dependency Injection and the idea that Singletons are global variables. Hopefully we will end up with a clearer picture of how, when and where to use the Singleton pattern (or not!).
TRACK 2
Security in .NET 4.0
Dominick Baier
The .NET Framework is now in its 10 year and 4th version. Technologies come and go – APIs and namespaces stay. Which are the essential security features and APIs in version 4 of the CLR and the .NET Framework? This talk gives an overview over all security feature areas of .NET v4 and details the new features as well as the (quite drastic) changes over v3.x.
TRACK 3
Let’s get XAMLfied
Dave Wheeler
WPF, WF and Silverlight developers should already be familiar with eXtensible Application Markup Language (XAML).
However, XAML is getting an overhaul, with far richer support for generics, parameterized constructors, and more.
If you’re planning to use XAML in your projects (and why wouldn’t you?), then you need to understand how the different XAML loaders and parsers work, and exactly when and how you should use it.
This session will cover this and more.
TRACK 4
Building RESTful services with WCF
Aaron Skonnard
WCF provides first-class support for building “Web” services that embrace REST design principles using standard Web protocols and data formats. This session illustrates how to build WCF services that support the HTTP uniform interface and different resource representations like XML, JSON, and Atom/AtomPub to enhance your Web 2.0 mash-up solutions. Throughout the session we’ll specifically look at some of the new features in WCF, the WCF REST Starter Kit and ADO.NET Data Services, and we’ll show you how to integrate them into your Web 2.0 solutions.
TRACK 5
ASP.NET Dynamic Data 4.0: RAD web sites (now even quicker!)
Ingo Rammer
ASP.NET Dynamic Data has been around since the first service pack for Visual Studio 2008. Together with the ADO.NET Entity Framework, it allows you to create data-driven web sites at an incredible speed while still allow you to fully customize the application. In this session, Ingo Rammer will show you how to build these kinds of web sites in record time. If you use Dynamic Data today, you will also learn about the new and coming features which will be part of .NET 4.0 to further simplify your development efforts.
TRACK 6
Emergent design
Neal Ford
Most of the software world has realized that BDUF (Big Design Up Front) doesn’t work well in software, but lots of developers struggle with this notion when it applies to design. Surely you can’t just start coding, right? You need some level of understanding before you can start work. This session describes the current thinking about emergent design, including both proactive (test-driven development) and reactive (refactoring, composed method) approaches to discovering design. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with the problem domain.
|
TRACK 7
Self-tracking objects in Entity Framework 4
Dino Esposito
When designing a multi-tier system, one of the most critical decisions for an architect to make is how to move data around the tiers. Tiers imply a physical distance between servers or processes; and crossing a tier inevitably raises concerns about performance. In the .NET space, two approaches emerged over years in some way backed by the .NET Framework and related tools. The most popular, and still largely used, is the approach based on DataSets. Another common approach is based on data-transfer objects (DTO). For different reasons, none of them can be considered the definitive solution. In this session, I’ll introduce a third approach – self-tracking objects.
Self-tracking objects are a specific feature of Entity Framework 4 and somewhat falls in between DataSets and DTOs. The session discusses the basic facts of self-tracking objects and while going through a concrete example it illustrates their internal implementation in Entity Framework 4.
TRACK 8
Aggregating data in SQL Server 2008 using grouping sets
Itzik Ben-Gan
A grouping set is a set of attributes that you group by. SQL Server 2008 introduces several features that allow you to easily and efficiently calculate aggregates for multiple grouping sets. With the new features you can address the needs to dynamically analyze aggregated data from the relational data warehouse. This session introduces the new features, the need that they serve, and how to use them to implement solutions that calculate, store, and incrementally update aggregated information.
|
17.30 |
Close |
|
