Advanced ETL application concepts with SSIS Christian Coté - SQL464 -> Material Evaluation Add to my schedule SSIS is more than appropriate tool for ETL development. It is very flexible and can be used as the main tool for your data warehouse / BI needs or any other application that require data movement. In this session, I will demonstrate: - Best practices using package configurations - Usage of logging to record package runs statistics - How to recover from an ETL application crash - ETL application deployment I will share my best practices on the above topics based on my previous experiences. This session can lead to ETL best practices discussions, which would be beneficial for all attendees.

Advanced performance troubleshooting - using XEven David Wei - SQL455 -> Material Evaluation Add to my schedule Extended events, or Xevents, is new feature in SQL Server. In this session, we will walk through several demos to show how to use Xevents to do advanced troubleshooting. .

Detecting and Troubleshooting Memory Bottlenecks Brad M. McGehee - SQL431 -> Material Evaluation Add to my schedule With memory being so inexpensive anymore, some DBAs think that if they are having a SQL Server performance problem, all they have to do is add more memory to their server to fix it. Unfortunately, adding more memory doesn’t resolve many performance issues. If a DBA suspects that a SQL Server instance is experiencing a memory bottleneck, they need to take the time and effort to thoroughly investigate if the performance problem they are experiencing is indeed memory-related, and if so, exactly what is causing the problem. If they don’t have this information, then making the decision to add more memory to boost performance can’t be reliably made. In fact, often DBAs add more RAM only to discover that performance doesn’t increase at all. In this session, attendees will learn how to use Performance Counters, Profiler Events, Extended Events, and DBCC commands to determine if their SQL Server instances are indeed having a memory-related performance issue, in addition to learning how to pinpoint the exact cause. Once the cause is determined, then the DBA has the data he or she needs to determine what steps should be taken to resolve the problem. In some cases, this may mean that more RAM needs to be added. But in other cases, it may instead mean that SQL Server configuration settings needs to changed, queries rewritten, or maybe the application is causing the problem.

End-to-End Troubleshooting for SQL Server 2005 Kevin Kline - SQL377 -> Material Evaluation Add to my schedule Learning how to detect, diagnose and resolve performance problems in SQL Server can be very difficult. It often takes years of on-the-job experience to learn how to use the tools and techniques that help you detect when a problem is occurring, diagnose the root-cause of the problem, and then resolve the problem. This hands-on session will take you from the very start of a problem situation on SQL Server, showing you how to use the native tools that help you keep SQL Server at top performance. This session will detail and demonstrate: 1) Performance Monitor, 2) SQL Profiler/Server-side Trace, 3) Correlating PerfMon and Profiler results, 4) Query plans, 5) DMVs, and 6) Trace Flags. These tools and techniques can make your long days shorter and make difficult troubleshooting activities much faster and easier. Every DBA needs to know how to keep their SQL Server in tip-top condition, and you’ll need these skills to do it.

Hosting the SQL Server Richard Baumet - SQL333 -> Material Evaluation Add to my schedule This presentation will cover over various things an IT pro should be aware of at the hardware layer and the Operating System. This can range from disk configuration on DAS, iSCSI or SAN, type of processors, OS configurations, NUMA, locking pages in memory, etc.

How to Use SQL Trace Brad M. McGehee - SQL356 -> Material Evaluation Add to my schedule For those who find that the SQL Server 2008 Profiler does not meet all their needs, or for those who prefer working programmatically with Transact-SQL System stored procedures instead of a GUI interface, there is SQL Trace. The session will include many demonstrations of how SQL Trace can be used, including: • Learn what SQL Trace can do • Learn how to implement SQL Trace • Learn how to automate SQL Trace • Learn how to analyze SQL Trace results

Identifying Performance Bottlenecks Joe Webb - SQL326 -> Material Evaluation Add to my schedule When a SQL Server application is under performing, how can you isolate where the actual problem is? Would more memory help? What about adding additional processors? Or maybe some indexes are missing? In this session, we will explore how SQL Profiler and Performance Monitor can be used to uncover your SQL Server's bottleneck.

Intro to SQL Integration Services Todd McDermid - SQL221 -> Material Evaluation Add to my schedule SQL Server Integration Services is a simple yet powerful tool for moving and transforming large volumes of data - but it does have a learning curve. If you've tried to figure out SSIS on your own, but haven't gotten further than creating a new project - this is the session for you. You'll find out how SSIS works, what it works best for, and when you should probably use another tool. Todd will demonstrate step-by-step construction of an SSIS package using standard components and techniques to solve a “typical” business scenario involving downloading files from an FTP server and loading the contents into SQL.

Introduction to Data Warehousing Jessica Moss - SQL244 -> Material Evaluation Add to my schedule Learn about building a data warehouse in this introductory session. We will discuss dimensional modeling, star schemas, Kimball methodology, and slowly changing dimensions. We will provide best practices for building a data warehouse and show all pieces of a working data warehouse.

MDX: From WITH To WHERE Jessica Moss - SQL354 -> Material Evaluation Add to my schedule After creating an Analysis Services cube, the data must be queried using Multidimensional Expressions (MDX). This session will discuss the basic syntax of MDX queries, common functions that can be used, and how to performance tune your queries. This session is best suited for people who are already familiar with Analysis Services cubes and multidimensional concepts.

Microsoft System Center Data Protection Manager Damir Bersinic - SQL384 -> Material Evaluation Add to my schedule How to Protect SQL Server Databases Using Microsoft System Center Data Protection Manager 2007 In this session you will be introduced to Microsoft System Center Data Protection Manager (DPM) 2007 and find out specifically how it can be used to protect SQL Server databases and transaction logs. You will find out how DPM leverages SQL Server VSS writer, and works with various SQL Server recovery models. You will also learn how DPM compares to other backup tools for SQL Server, as well as new enhancements for SQL Server protection in DPM 2007 SP1.

Microsoft Windows 2008 HPC Server cluster Pedro Manfredi - SQL214 -> Material Evaluation Add to my schedule overview of the Windows 2008 HPC Server cluster technology along with the supporting Microsoft technologies for operations and management. Covers the new featurs such as the service oriented architecture, system center integration, profiling and performance systems. Covers the WIndows 2008 HPC Pack including job scheduler, cluster manager, service broker and support for MPI programming.

Powershell'd - How to Powershell Your Way with SQL Donabel Santos - SQL312 -> Material Evaluation Add to my schedule Powershell'd - How to Powershell Your Way with SQL Server 2008 If you have used any kind of shell scripting before, you know how it can help automate tasks quicker and more efficiently. Powershell, a scripting language that leverages Microsoft .NET Framework, is finally supported in SQL Server. This session will dive deep into how you can use Powershell to create, maintain, manage and troubleshoot your SQL Server databases. This session will also cover differences between using Powershell in SQL Server 2005 and 2008.

Project Madison: Scale-out of SQLServer Tamer Farag - SQL240 -> Material Evaluation Add to my schedule Project Madison: Scale-out of SQLServer Datawarehouses on a MPP Architecture Building on the technology from the acquisition of DATAllegro, this session will describe the forthcoming MPP architecture for SQL Server Data Warehousing, its design principles, operation and best practices for scaling databases ranging from 50TB to 1 Petabyte. Strategies for loading data, data distribution, system tuning and running mixed-workloads will be discussed, along with a roadmap and timeframe for early customer engagement.

Reusing your SSIS Scripts by using custom tasks Todd McDermid - SQL379 -> Material Evaluation Add to my schedule Reusing your SSIS Scripts by converting them to Custom Tasks and Components SQL Server Integration Services provides a very easy way to extend its capabilities by using the Script Task and Script Component. However, the code stored in those components isn’t reusable – so if you have some custom logic that you need to reuse in several places in one package (or in several packages), code maintenance can be extremely difficult. Find out how to take the code you’ve made in a Script Task or Script Component and convert it into an easily reusable Custom Task or Custom Component.

SQL Server 2008 Data Compression and Backup Damir Bersinic - SQL362 -> Material Evaluation Add to my schedule SQL Server 2008 Data Compression and Backup Compression - Notes from the Field In this session you will learn from real-world customer experiences on when to use SQL Server 2008 data compression and backup compression. You will also find out about best practices of how and when to implement these technologies, and where they do not make sense. You will see demonstrations comparing and contrasting performance with and without compression.

SQL Server 2008 Virtualization Using Windows Damir Bersinic - SQL325 -> Material Evaluation Add to my schedule SQL Server 2008 Virtualization Using Windows Server 2008 Hyper-V In this session you will learn when to run multiple instance of SQL Server on a server versus when it makes sense to consolidate using Hyper-V. You will also find out what are recommended best practices for running SQL Server in Hyper-V virtual machines, monitoring strategies, and performance considerations for running virtualized SQL Server workloads.

Top 10 Features of SQL Server 2008 Kevin Kline - SQL234 -> Material Evaluation Add to my schedule Learning about the most significant features in a new release of SQL Server can be daunting work because there are so many new features to examine. This session will detail a variety of the most significant new features from the perspective of a DBA. During the course of this session we will discuss improvements and new features within the relational engine, Reporting Services, Analysis Services, security, and administration.

Understanding the Procedure Cache Bill Graziano - SQL321 -> Material Evaluation Add to my schedule Understanding the Procedure Cache: Writing Efficient, Reusable Queries When is a query plan reused? When will dynamic SQL give better performance results than stored procedures? What are the benefits of a compiled query plan? When should you turn on forced parameterization? What is the most efficient way to write SQL for reports that might have wildly different WHERE clauses? Why is my stored procedure very slow somtimes? How effecient is the SQL from LINQ? How effecient is the SQL from ORM tools?

Using SQLdiag to Troubleshoot SQL Server Problems Brad M. McGehee - SQL367 -> Material Evaluation Add to my schedule While SQLdiag is often considered a tool for helping Microsoft Customer Support to help DBAs resolve their SQL Server problems, it can also be a great tool for DBAs. In one handy utility, you can capture diagnostic information from the Windows Performance logs, Windows Event logs, Profiler traces, blocking information, server configuration information, and much more. In this session, attendees will learn what SQLdiag offers them, how to use its many options, and how to analyze the results. The focus of the session will be on demos on how to implement the tool to resolve the kind of real life problems DBAs face on a day-to-day basis.

Building and Deploying Databases Data Dude Don Kiely - SQL361 -> Material Evaluation Add to my schedule Building and Deploying Databases with Data Dude 2008 Visual Studio has long included some basic tools for building and modifying databases, but they were pretty lame. That all changed with the initial release of Data Dude—er, Visual Studio Team System Database Edition—a set of tools for creating and deploying databases, complete with support for versioning in a source control system. The tools were kind of cool through the release of Visual Studio 2008, but the latest GDR release takes the tools to a whole new level. During this session, we’ll explore some of the incredible features of Data Dude that help you build databases and deploy them to a production server. There is an amazing amount of power in these tools, and the GDR release brings features like partial and composite projects, support for SQL Server 2008, refactoring, comparing schemas, T-SQL static code analysis, and extensibility. You’ll also learn about the Data Dude Power Tools, a set of extensions that will make your database development life even easier. This session isn’t for database novices; come prepared to be blown away by what you can do within Visual Studio 2—8 and Data Dude!

Choosing the Right Encryption Methodology Peter DeBetta - SQL392 -> Material Evaluation Add to my schedule SQL Server 2008 now has a feature called Transparent Data Encryption, which can encrypt your data without any application changes required. But is it the ultimate solution for encrypting your data. This session will discuss various options for encryption, including Extensible Key Management, Transparent Data Encryption, and other built-in encryption capabilities.

Creating Dashboards with PerformancePoint Server Jessica Moss - SQL396 -> Material Evaluation Add to my schedule The monitoring and analytics (M&A) portion of PerformancePoint Server allows companies to manage their key performance indicators. This session will discuss methods of designing dashboards, deployment scenarios, and ways to integrate SharePoint with the PerformancePoint dashboard. While the next version of the PerformancePoint Server M&A will be included in SharePoint, the design concepts from PPS 2007 will still be applicable in future versions.

Creating Data-Driven Subscriptions in SSRS Joe Webb - SQL342 -> Material Evaluation Add to my schedule Providing information to those that need it when they need it is key for many businesses. But, being able to automatically disseminate critical information in a timely fashion can be a challenge. In this session, we will discover how data-driven subscriptions in SQL Server Reporting Services can be used to effectively deliver reports to a varying list of subscribers.

Deciphering transaction log files Hugo Shebbeare - SQL472 -> Material Evaluation Add to my schedule Deciphering transaction log files - why a developer should care about them. Looking into the guts of a log file allows you to what values existed before and after a change, which application/user/login made the change - and most importantly enables us to restore certain desired cross-cuts of transactions in time. This helps resolve corruption mysteries also.

How and When to Implement Indexed Views Brad M. McGehee - SQL371 -> Material Evaluation Add to my schedule Indexed views are an often misunderstood and underused feature of SQL Server that more DBAs should learn to master. In this session, you will learn: • Features and Benefits of Using Indexed Views • Learn Where Indexed Views Work Best • Learn How to Implement Index Views • Learn Indexed Views Best Practices

Locking and Blocking Made Simple Joe Webb - SQL212 -> Material Evaluation Add to my schedule A good working knowledge of how SQL Server makes use of locking and transaction isolation levels can go a long way toward improving an application's performance. In this session, we will explore SQL Server's locking methodology and discover techniques for enhancing query response times.

Managing Hierarchies in SQL Server 2008 Peter DeBetta - SQL267 -> Material Evaluation Add to my schedule Managing Hierarchies in SQL Server 2008 with HIERARCHYID Managing hierarchical and tree structure data in any data store can be challenging. Several techniques exist that can solve the problem of modeling and implementing this type of data. This session shows you how to design and implement these different techniques, including the new HIERARCHYID, for managing hierarchical data structures in SQL Server 2008.

Resource Governor Peter DeBetta - SQL233 -> Material Evaluation Add to my schedule Resource Governor is a new feature in SQL Server 2008 that allows you to control, well, the amount of resources used by various processes. This sessions will show you how Resource Governor works and how to implement this great new feature.

SQL Server 2008 Reporting Services Programming Roman Rehak - SQL244 -> Material Evaluation Add to my schedule SQL Server 2008 Reporting Services provides rich and powerful programming framework. This session will give you an overview of many available options for programming Reporting Services. We will cover the Reporting Services Web Service, URL Access, ReportViewer and custom assemblies. We will also talk about integrating reports into both Windows and Web applications.

SQL Server Application Optimization and Tuning Roman Rehak - SQL359 -> Material Evaluation Add to my schedule This session will provide recommendations for writing efficient SQL Server applications as well as introduce tools and techniques for performance tuning, monitoring, query optimization and indexing. The first part will provide Transact SQL and ADO.NET tips for improving application performance. The second part will focus on server and database tuning, showing you how to use SQL Server client tools such as SQL Profiler, Activity Monitor as well as custom procedures for performance monitoring and tuning.

SQL Server Development Tips and Tricks Roman Rehak - SQL232 -> Material Evaluation Add to my schedule This session will cover many common issues, challenges and problems encountered when developing for, or administering SQL Server as well as examining best ways to modify, script and copy database objects from development to production environment. Session materials for the attendees will include custom utility tools and stored procedures written by the speaker for simplifying SQL Server development and database update deployment.

SSMS Tips, Tricks, Traps, and Treats Don Kiely - SQL387 -> Material Evaluation Add to my schedule Sql Server Management Studio 2.0: Tips, Tricks, Traps, and Treats The SQL Server 2008 story isn’t really about productivity, but the latest version of Management Studio has definitely come of age. There are all kinds of tools and useful information throughout the environment, masking the complexity of and sometimes enhancing the underlying database server features. During this session we’ll shine a light into the various nooks and crannies of this useful tool for both developers and administrators. You’ll learn about the new activity monitor, Intellisense (and how to keep it from driving you nuts, particularly if you are used to Visual Studio), T-SQL debugging, object explorer details enhancements, and lots more. You’ll learn various tips and tricks to make the most out of this tool.

Stored Procedure Best Practices Kevin Kline - SQL265 -> Material Evaluation Add to my schedule Find out the tricks and techniques needed to make SQL Server stored procedures achieve top performance. Numerous tips will show you how to make your stored procedures run faster, with fewer errors, and with better reliability. This class assumes a basic understanding of Transact-SQL.

Tips & Tricks for Writing Better Queries Joe Webb - SQL382 -> Material Evaluation Add to my schedule Transact-SQL is not a very difficult language to learn. As long as the syntax is correct, it can be quite forgiving. However to truly get the best performance from your SQL Server, careful consideration should be given to the structure and logic of the queries. In this session, we'll discuss some Transact-SQL tips and tricks that can be employed to help you write better queries, allowing your server to perform better.

Tracking Metadata in a BI Solution Jessica Moss - SQL349 -> Material Evaluation Add to my schedule Tracking Metadata in a Business Intelligence Solution An important aspect of business intelligence solutions is knowing how data was entered and changed in the system. This data about data, also known as metadata, can assist in complying with laws, answering business questions, and auditing issues. In this session, learn how to store, track, and manage the metadata in your BI system.

Adopting Team System 2008 Etienne Tremblay - VST345 -> Material Evaluation Add to my schedule You have seen the Team System overviews, you are stoked and want to start using the product but you’re not sure where to start? This session is for you, in it we will open the box and look inside, we will discuss the various installation scenarios (solo developer or for a group, hardware vs. Virtual), the difference between the various Visual Studio SKUs, the adoption rate of all the new features now available in VSTS and how we should adopt them, and finally touch on Customization of Team Foundation Server. We will finish with the best practices of usage.

Advanced Unit Testing with Team System Barry Gervin - VST378 -> Material Evaluation Add to my schedule In this session we'll go beyond the basic unit testing and discuss best practices for building quality into the development process, including patterns for writing effective and maintainable tests, and naming conventions. We'll cover not just code coverage but functional coverage, data driven unit testing, integrating test artifacts between QA and Development and load testing. We'll also explore how unit tests relate to requirements, builds, and bugs and what it really means to publish your test results against a build and provide meaningful project reporting data through the development lifecycle. Developers, Testers, and Project Managers will all find value in this session.

Agile Development & Scrum with VSTS Claude Rémillard - VST234 -> Evaluation Add to my schedule Scrum is an Agile process framework that allows organizations to continuously direct their project toward early delivery of real business value through the frequent and regular delivery of high quality software. This session will explore how the Scrum process is supported in VSTS by the Scrum Conchango template. The session follows the overall flow of a project to review the implementation of all the key elements of Scrum such as: Product Backlog Items, Sprint Backlog Items, Sprint Backlog Bugs, Scrum queries and the Scrum reports including the Sprint Burndown Chart, the Product Burndown Chart and the Product Backlog Composition reports. Use of the Microsoft Office tools to manage the product backlog and release planning is also covered.

Building and deploying a database Project Christian Coté - VST374 -> Material Evaluation Add to my schedule Building and deploying a database professionnal project Visual Studio team System for Database Professional is incredibly useful when it comes to manage databases. In this session, I will show how to use builds capability to deploy a database to various environments (Dev/Test/UAT/Production). I will also demonstrate how the data generator can be used efficiently to transfer data from environments at deployment. Also, how unit tests can be used and extended to assess successful database deployment.

Leveraging VSTS for mature SharePoint Development Claude Rémillard - VST322 -> Evaluation Add to my schedule As more organizations are turning to SharePoint to develop business applications they soon realize that SharePoint does not provide the platform for the mature management of the application life-cycle . This session will present how to leverage VSTS with Concerto for SharePoint, a toolset that integrates SharePoint with VSTS. We will present how to manage multiple developers on the same SharePoint application without stepping on each other’s feet, how to implement a simplified and repeatable deployment process through different test environment and how to apply VSTS capabilities such as code traceability, continuous integration and centralized source control with all associated best practices.

Managing Database Professional Projects Christian Coté - VST383 -> Material Evaluation Add to my schedule Manage your database using Visual Studio for Database Professional Too many times, database maintenance and deployment represent a challenge during application development. This session will demonstrate how Visual Studio Team System for Database Professionals (VSTS4DBP) can ease database deployment while being integrated into version control. Database unit tests and generic data generation that can be used for development will also be demonstrated and discussed.

Real World Best Practices for Source Control Barry Gervin - VST348 -> Material Evaluation Add to my schedule In this session we'll cover structuring solutions & projects to minimize dependencies and maximize developer productivity. We'll discuss effective practices and good habits for maintaining a clean source control repository and minimizing build breaking checkins. We'll run into common problems such as "My Get Latest Didn't, WTF?", "Who wrote that code?", "It wasn't me that broke the build!" and it's close friend "It worked on my machine!". We will discuss effective branching models for release management & maintenance. You'll come away from this session understanding The Art of the Merge: A primer in conflict resolution, and Shelvesets: What are they good for?

Software Development Metrics with VSTS Claude Rémillard - VST216 -> Evaluation Add to my schedule Development teams are more than ever asked to do more with less and it is often difficult to define the “more” and the “less”. This session will present what role can the VSTS metrics and capabilities can play in the complete Extract->Evaluate->Execute cycle of a measurement program. We will cover how to leverage these metrics for sizing and estimation, process improvement, product quality monitoring and operational management at the portfolio and project levels.

Team System Process Customization Etienne Tremblay - VST372 -> Material Evaluation Add to my schedule In this session we’ll talk about how to customize a process template, the tools you need and what you should change and about the existing Process template available. We’ll cover the Work Item Type, Work item workflow, Sharepoint Template Creation (basic).

Top 10 new things in TFS Etienne Tremblay - VST365 -> Material Evaluation Add to my schedule Top 10 new things in Team Foundation Server and Team System 2008 Come join me in demo session about my Top 10 new things in Team System 2008. We will look at both the server features as well as the client features. Things like Annotate, Directory Compare, Continuous Integration, Queue builds, Performance hotspots will be at the honor. If you are new to Team System or have been using it for a while you’ll be interested in seeing what cool new feature are coming the Team System 2008.

Increase testability with a modular architecture Mario Cardinal - POS366 -> Material Evaluation Add to my schedule This workshop has been designed to give you a head start in modular architecture practice with abstractions such as the “layer”. You will acquire fundamental knowledge about how to partitions into layers the concerns of the application. We will teach you the best practices regarding application architecture and modularity. We will demonstrate how to apply “top-down” as well as “test-driven” design techniques. You will learn how to correctly design the “velcro”, the visible interface of a module. In the same way, you will learn how to conceive a “fake” implementation, an efficient practice to test a module in an autonomous way. Using a real case study, students will learn how to implement a layered architecture using C# language and Microsoft .NET framework. At the end of this workshop you will understand why architects require a unit of modularity that goes beyond object.

Microsoft’s new ADO.NET Entity Framework Julia Lerman - POS344 -> Evaluation Add to my schedule Spend the day learning about Microsoft’s new ADO.NET Entity Framework, Microsoft’s new core data platform, with Julie Lerman, the leading independent authority on this technology and author of O’Reilly’s Programming Entity Framework. Julie has been working with Entity Framework since it was first announced by Microsoft, writing and teaching about it and working with the Entity Framework team to help shape the product.

Security from ASP.NET to SQL Server by Peter Debet Peter DeBetta - POS378 -> Material Evaluation Add to my schedule Duo with Don Kiely Do you value your data? How about the integrity of your Web applications? Then plan to attend a full day workshop this June in Vancouver, B.C. after the DevTeach conference. Peter W. DeBetta and Don Kiely will cover "Security from ASP.NET to SQL Server," exploring application and data security from front to back, throughout an ASP.NET application based on SQL Server. We'll start with your data, using SQL Server's features to keep it safe and secure. Then we'll move to the Web server, showing you how to keep data secure in transit and while the user is working with it. You'll see a lot of code, get a grasp of the concepts, and leave with plenty of practical information about creating a secure ASP.NET application.. The seminar will cover new features in SQL Server 2008 where relevant.

Agile Development with IoC and ORM by James Kovacs James Kovacs - PRE389 -> Material Evaluation Add to my schedule As developers we now have powerful tools in our toolbox, such inversion of control containers and object-relational mappers. But how can we use these tools to rapidly build maintainable and flexible applications? In this pre-con, we will look at advanced techniques such as convention-over-configuration in IoC containers and automapping ORMs to quickly build applications that can evolve over time. We will use test-driven development (TDD) to design and evolve a complete working application with supporting infrastructure during this one-day workshop.

Building Better .NET Applications with F# Amanda Laucher - PRE323 -> Evaluation Add to my schedule With the release of Visual Studio 2010, Microsoft will introduce a new programming language, Visual F#, to the mainstream .NET development community for the first time in close to a decade. Visual F# represents a new style of programming, a functional approach to programming, historically characterized by "academic" languages like Haskell and ML. In this pre-conference tutorial, we'll examine the 'why's of F#, including the benefits and drawbacks of a functional programming style, and how it can be combined with object-oriented programming to take best advantage of both approaches. Along the way, we will write some F# code, giving the attendee a strong basis of F# syntax that they can use to learn more about F# back home. By the end of the pre-con, in fact, attendees who bring their own laptops and attack the exercises provided will have enough skill at F# to begin writing F# code that can be called from C# in a variety of different contexts.

Building Business Applications with Silverlight 2. Rod Paddock - PRE201 -> Material Evaluation Add to my schedule Duo with Jim Duffy Make plans to stay an extra day after the conference to take advantage of this opportunity to join veteran software developers Rod Paddock and Jim Duffy as they give you a head start down the road to developing business-oriented Rich Internet Applications (RIA) with Microsoft Silverlight 2.0. In case you just crawled out from under a rock, Microsoft Silverlight 2.0 is a cross-browser, cross-platform, and cross-device plug-in positioned to revolutionize the way next generation Rich Internet Applications are developed. Microsoft’s commitment to providing an extensive platform for developers and designers to collaborate on creating the next generation of RIAs is very clear and its name is Silverlight 2.0. In this intensive, full-day workshop, Rod and Jim will share their insight and experience building business applications with Silverlight 2.0 including a review of some of the Internet’s more visible Silverlight web applications. Make it a priority to not let yourself or your organization get left behind. Come join Rod and Jim as they provide an in-depth look at the future of Rich Internet Application development with Microsoft Silverlight 2.0.

A Look at Windows Azure Data Services Michael Stiefel - ARC321 -> Material Evaluation Add to my schedule Do Databases In the Cloud Make Sense? A Look at Windows Azure Data Services Most applications require some means to save data. But if you put that data in a computing cloud, the requirements of consistency, availability, and partitioning can conflict. That means to have a highly available and scalable application you may have to give up classic ACID database transactions and relational database features such as foreign keys, joins, and stored procedures. How do you handle versioning of data and data latency? This talk will describe these problems and talk about how to architect and design in this new world.

Advanced Debugging Greg Young - ARC374 -> Evaluation Add to my schedule Good developers never create bugs in their own code, but they are frequently called upon to find and squash the bugs that mysteriously work their way into code due to "environmental issues". We start with how to set up an enterprise environment to enable us to be more efficient in combating problems and then we delve deep into VS.NET and SOS learning strategies to combat even the ugliest heisenbugs including memory and locking problems.

Agreeing to Agree Greg Young - ARC357 -> Evaluation Add to my schedule Contracts are an important part of Object Oriented Design. This presentation looks at the introduction of contract based specifications to BDD.

Architecting Software as a Service Michael Stiefel - ARC327 -> Material Evaluation Add to my schedule Architecting Software as a Service: Business or Technology Problem? Architecting and building a Software as a Service application requires solving a series of problems that are independent of a particular software platform. First, a SaaS architecture follows directly from the fundamental principles of the business model. Second, a series of difficult technical problems must be solved in addition to providing the business functionality. These include certificate security, low-IT-capable clients, business continuity when connectivity is lost, high availability, adjusting to elastic demand (both scaling up, or scaling down), provisioning of services, scalability as the number of clients increase, database design for clients, thin vs thick clients, how to use virtualization, and how to integrate and release service functionality over several different client applications. Third, you have to effectively use the platform technology such as WCF and ASP.NET, or Windows Azure. This talk discusses how to architect and design a SaaS application.

Automated UI Testing – the Prism project Larry Brader - ARC301 -> Material Evaluation Add to my schedule Automated UI Testing – Practices and lessons learned from the Prism project In this talk we will deal with the nuts and bolts of tools and process considerations for doing test in an agile development environment. First a discussion of the test process learning's over the years to work most effectively per iteration and strategic considerations for the overall projects. Second part of the discussion are tools and strategy for test regressions, detail the implementation of a VSTS Build system for automation of test for continuous testing and finally the implementation of VSTS Performance environment. On the automation the focus will be implementing the UI automation. The tools for testing can be effectively developed and grown during each iteration so after shipping you can leverage these environments for support engineering or the next big project cycle.

Becoming an Architect Rob Daigneau - ARC378 -> Material Evaluation Add to my schedule So you think you know what it means to be a software architect? Are you sure? Some people simply equate software architecture with the design of things like services, interfaces, applications, and so forth. In practice, software architecture and the responsibilities of the architect encompass much more than you might think. Join us in this session as we explore what it means to be a software architect from one who knows. We’ll take a look at the different species of architects, the work of the architect, the skills required to do the job, and some common issues the architect must confront. We’ll also attempt to answer the question, "Should architects code?"

Busy .NET Developer's Guide to Functional Concepts Ted Neward - ARC386 -> Evaluation Add to my schedule For many .NET developers functional programming represents both an opportunity and a challenge. Opportunity, in that functional programming can make a whole range of tasks much, much easier; challenging, in that functional programming represents an entirely new way of looking at how to think about designing and writing .NET code. In this presentation, we'll examine functional concepts that you can use to make your development more concurrent, more succinct, and more maintainable without losing many of the benefits of object orientation.

Cloud Computing Architecture Mario Cardinal - ARC341 -> Material Evaluation Add to my schedule This presentation has been designed to give you a head start understanding "Cloud Computing" architecture. You will acquire fundamental knowledge about scale-out storage, blobs and queue as well as the difference between a web and a worker module. At the end of this session you will understand who will benefits from Cloud Computing.

DSLs and LOP Amanda Laucher - ARC366 -> Evaluation Add to my schedule Domain specific languages are miniature languages aimed at allowing code to resemble the actual problem domain. We'll go through some patterns and techniques for creating them. With examples of both internal and external, you'll see how DSLs can save on development time, and maintenance. We'll also discuss some of the things to watch out for. Examples in C#, F#, and Mg.

Modular Architecture Mario Cardinal - ARC433 -> Material Evaluation Add to my schedule Add a visible interface and a test-bed to your layers This presentation has been designed to give you a head start in modular architecture practice with abstractions such as the “layer”. You will acquire fundamental knowledge about how to partitions into layers the concerns of the application. We will teach you the best practices regarding application architecture and modularity. We will demonstrate how to apply “top-down” as well as “test-driven” design techniques. You will learn how to correctly design the “velcro”, the visible interface of a module. In the same way, you will learn how to conceive a “mockup” implementation, an efficient practice to test a module in an autonomous way. Overall, you will learn how to design for testability and why we need a unit of modularity that goes beyond object.

Pragmatic Architecture Ted Neward - ARC355 -> Evaluation Add to my schedule Building an application is not the straightforward exercise it used to be. Decisions regarding which programming languages to use (Java, .NET, even FoxPro), which architectural approaches to take (n-tier, client/server), which user interface approaches to take (Smart/rich client, thin client, Ajax), even how to communicate between processes (Web services, distributed objects, REST)... it's enough to drive the most dedicated designer nuts. This talk discusses the goals of an application architecture and why developers should concern themselves with architecture in the first place. Then, it dives into the meat of the various architectural considerations available; the pros and cons of Silverlight, ClickOnce, Windows Presentation Foundation, WinForms, WebForms, Ajax, RMI, .NET Remoting, ASMX, Windows Communication Foundation, Windows Workflow Foundation, MSMQ, transactional processing, and more.

REST vs WS* Service Smackdown Rob Daigneau - ARC368 -> Material Evaluation Add to my schedule Two camps have risen in the SOA world, the RESTafarians and the WSDL-ites. Each has passionately argued that they are the one true path. Now they need battle no longer, for in .Net 3.5 they have been brought together into the same happy WCF family. In this session we’ll dive into the tenets of REST, and consider when to use it versus WS* types of services. Not only that, but we’ll see how the same service can be created in the REST and WS* styles with C# and WCF.

Rethinking "Enterprise" Ted Neward - ARC369 -> Evaluation Add to my schedule The era of the big, heavy, transactionally-oriented client/server topology, as best described by the J2EE Specification and Blueprints document, seems to be over. The era of the lightweight, transactionally-oriented client/server topology seems to be at its zenith. Is this really where we want to be when building enterprise systems? And how did we end up here, anyway? What's the new "enterprise" developer supposed to do?

The joys/concerns of multi-paradigm programming. Amanda Laucher - ARC344 -> Evaluation Add to my schedule The joys/concerns of multi-paradigm programming. Choosing the right tool for the job. Are you still choosing a language for solving a problem by "That’s the way we've always done it?" Object oriented, functional, declarative, imperative - do we really know what these terms mean and when should you use what? Lets look at a more pragmatic approach to writing software. We'll look at where and when to use what as well as how mixing the paradigms can add value OR complexity.

Top 10 Umbrellas Erik Renaud - ARC393 -> Evaluation Add to my schedule Duo with François Tanguay Umbrella is an open source framework that fills the gap when using different .net technologies. We would like to show you 10 tricks that Umbrella uses in order for you to write less code and be more productive. It`s more than just code though, it`s also new patterns and new paradigms that will make you rethink the way you create software. Even if you are not using Umbrella on your current project, you will be able to take some ideas home with you. How far have you pushed the decorator pattern ? Have you ever used composites ? What about those things Umbrella calls “Extensions Points” ? We guarantee this session will inspire you.

Two-Phase Commit is Evil Rob Daigneau - ARC323 -> Material Evaluation Add to my schedule Distributed transactions have been a part of the developer’s toolkit for a long time. Many assume that when resources like databases are not centralized, we must use distributed transactions. However, there is a dark side we must be prepared to confront if we follow this path. In this session we’ll come face to face with the devil, and learn how to defeat him. We’ll delve into the CAP theorem, and present a few real-world examples that demonstrate the wisdom this theorem encapsulates. We’ll also explore several alternatives to distributed transactions, and review the trade-offs associated with these approaches.

Unleash your domain Greg Young - ARC382 -> Evaluation Add to my schedule Our application runs over 10,000 sustained transactions per second with a rich model. The key? Modeling state transitions explicitly. This presentation analyzes a few real world projects where this decision was made and the many interesting modeling/architectural possibilities that arose from the decision.

A lap around the Silverlight Toolkit and SDK Justin-Josef Angel - SLV323 -> Evaluation Add to my schedule A lap around the Silverlight Toolkit and Silverlight SDK Controls "The rate in which Silverlight is changing now days is just staggering and sometimes might be a bit overwhelming. Recently in November 2008 Microsoft shipped the Silverlight Toolkit. The Silverlight Toolkit is a collection of Silverlight controls, components and utilities made available outside the normal Silverlight release cycle. Join Justin Angel as he gives you the grand tour of the Silverlight Toolkit and Silverlight SDK Controls. When you go to work next week - you will know everything you need to know about the Silverlight Controls. How does AutoCompleteBox filter items? How does ImplicitStyleManager change styles? How does DockPanel position items? How do we globalize TimePicker? and many more questions will be answered. Justin Angel is a Microsoft Silverlight Program Manager. He was so deeply involved with shipping the Silverlight Toolkit that he was the one to press the mythical ""Ship it!"" button."

Architecting Applications In Silverlight D'Arcy Lussier - SLV364 -> Evaluation Add to my schedule Silverlight can be thought of as a hybrid presentation technology, sharing pieces of ASP.NET and Winform development. This means that architecting a Silverlight application has its own unique challenges and considerations. This session will cover areas like communcation channels, deployment, security, and layering. (Note: Developing Applications in Silverlight session is recommended as a pre-requisite but not required)

ASP.NET Integration With Silverlight D'Arcy Lussier - SLV341 -> Material Evaluation Add to my schedule While some websites could be written entirely in Silverlight, some websites only require Silverlight for certain parts. We'll look at these scenarios in depth and cover how a Silverlight application can interact with an ASP.NET application from within the browser, interface with javascript, and communicate with other Silverlight applications on the same page. (Note: Developing Applications in Silverlight session is recommended as a pre-requisite but not required)

Building Behaviors in Silverlight 3 Shawn Wildermuth - SLV363 -> Material Evaluation Add to my schedule The ability to attach verbs to objects in Silverlight 3 represents a powerful extension to the data bound model. In this talk I will build a Behavior using managed code then and show how it works in Blend 3 and XAML.

Deep diving into Silverlight UI framework Justin-Josef Angel - SLV354 -> Evaluation Add to my schedule Deep diving into Silverlight UI framework through Silverlight controls In first glance Silverlight seems to have a pretty extensive learning curve. And what do we as developers do when confronted with "framework magic"? We stick to the basics and tend to roll our own mini-framework. In this talk we'll uncover and unmystify all sorts of Silverlight/WPF framework magic and we'll try to get a better understanding of those. Some of these hardcore Silverlight concepts include: * The VisualStateManager - How does a button animate it's visuals when clicked/hovered? * DataTemplates - How does ListBox know the template of it's item? * ItemsControls - How does ComboBox generate ComboBoxItems from CLR Instances? * Re-Templating - How does Expression Blend allow us to transform a ListBox to a solar system? Justin Angel is a Microsoft Silverlight Program Manager.He was so deeply involved with shipping the Silverlight Toolkit that he was the one to press the mythical "Ship it!" button.

Enhance SharePoint with Silverlight 2.0 Medhat Elmasry - SLV388 -> Material Evaluation Add to my schedule Take SharePoint to the next level. Learn about how to configure your development environment and the SharePoint 2007 server so that Silverlight 2.0 can be hosted in a Web Part. Once that is out of the way, we will build some simple Silverlight applications and deploy them into SharePoint. During the journey, we will consume a SharePoint web service in Silverlight, use WCF Data Binding and also learn about available tools that can significantly facilitate matters.

Navigating the DMZ Shawn Wildermuth - SLV352 -> Evaluation Add to my schedule The Blend/Visual Studio story is supposed to bring peace to the ongoing battles between developers and designers. But there are real world hiccups in how this integration works. In this session, I will highlight lessons learned from the field to help you turn your cease-fire into a full-fledged peace.

Silverlight + MVVM = Easy Shawn Wildermuth - SLV344 -> Material Evaluation Add to my schedule Building a simple gadget or proof-of-concept in Silverlight is a pleasurable experience. But for larger applications, we should be able to leverage some of the tried and true software development patterns to help us build reliable and robust solutions. One of the most power of these techniques is the model-view-view-model (MVVM) pattern. In this session, I will present a example of building your applications using the MVC pattern to enable testability and separation of concerns.

Silverlight - A Thorough Introduction Michael Forth - SLV256 -> Material Evaluation Add to my schedule Silverlight - A Thorough Introduction Using Lots of Code This session will allow someone to become familiar with a number of key aspects of Silverlight 2 through the use of many demos. About 50% of the time will be reviewing code snippets and exploring the potential of the technology through examples.

Silverlight Case Study: Code Camp Application D'Arcy Lussier - SLV357 -> Material Evaluation Add to my schedule For the recent Winnipeg Code Camp, we created a Silverlight based site. You'll be walked through the development of the application from start to finish, and I'll share the lessons learned from the experience.

Silverlight Frankenstein Rod Paddock - SLV233 -> Material Evaluation Add to my schedule This session will focus on using Silverlight to solve a single problem combining the Sliverlight Plugin, Jquery, JSON and some interesting Javascript programming. This session will be entiirely code focused and will provide you with insights of non visual uses of Silverlight.

Styling and Multimedia In Silverlight D'Arcy Lussier - SLV378 -> Evaluation Add to my schedule One of the biggest attractions to Silverlight is the ability to make an application look amazing. This session focusses entirely on styling and presentation of a Silverlight application. We cover styles, templates, animation, customization of controls, and integrating media such as videos and sound. (Note: Developing Applications in Silverlight session is recommended as a pre-requisite but not required)

The Challenge of Silverlight Architectures Kathleen Dollard - SLV317 -> Material Evaluation Add to my schedule Silverlight represents a sweet spot between rich client WPF and WinForms applications and the ease of web deployment. Now that .NET code runs on the browser client, we’re confronted with the many differences between the two versions of the CLR. A valid question arises about what code should run on the client. This talk looks at the mechanics of the problem – how to reuse code across the two platforms, how to pass data between the platforms, and how to support databinding. Then it launches into issues of authorization, validation and calculations. You’ll see both a DTO (Data Transfer Object) and a mobile object solution to these problems before diving into some of the great support for visualizing data, such as the Visual State Manager. This talk presents Silverlight from the perspective of a rich client programmer demanding all the functionality and ease of coding inherent in the stateful, intelligent Silverlight model.

Using the Composite Application Guidance for WPF Claudio Lassala - SLV256 -> Evaluation Add to my schedule This presentation covers the Composite Application Guidance for WPF (codename Prism), its architecture and Composite Application Library (CAL), and how applications are be built on top of it. If you build any application that goes beyond "Hello World", it's likely that you create composite applications. Prism allows for applications to be built with proper separation of concerns, promoting loose coupling, extensibility, and testability. It also helps with WPF and Silverlight goals of allowing developers and designers to collaborate more easily on the same project. The presentation also cover some dependency injection and Model-View-ViewModel patterns.

Will It Blend? Shawn Wildermuth - SLV312 -> Material Evaluation Add to my schedule It’s easy to assume that the Expression toolset is just for designers. It’s even got that cool dark background with a completely non-Windows looking skin. But is that the reality? In this session I will show developers how Blend can be used to make their jobs quite a bit easier, even without a single ounce of artistic talent.

An Overview of Oslo Matt Winkler - NET231 -> Evaluation Add to my schedule "Oslo" is the family of new technologies that enable data-driven development and execution of services and applications. This session will describe the key platform components: the M family of languages, the Repository and tooling. Additionally we’ll cover the developer scenarios Oslo will deliver in v1 and provide a view into the longer term goals.

An Overview of the MEF John Bristowe - NET348 -> Material Evaluation Add to my schedule An Overview of the Managed Extensibility Framework (MEF) The Managed Extensibility Framework (MEF) is a new extensibility model in the .NET Framework that provides a simple declarative model for application developers and extenders to build openly extensible applications. Come to this session and you'll learn about our Composition model and the APIs that work with it. You'll learn about composable parts, exports, imports and the composition container that brings them all together. You'll see how using the model you can develop open-ended applications that can easily be extended both internally and by third-parties.

Building an Application with Oslo Matt Winkler - NET371 -> Evaluation Add to my schedule In these 75 minutes, we’ll start from an idea and build an application using Oslo. We’ll pull together the pieces of the Oslo platform, MSchema, MGraph and MGrammer to build our application. Along the way, we’ll discuss practical issues, such as testing the models as they are built, handling changes to the application, security, replication and common patterns that emerge when modeling data. We’ll also cover how to build a data-driven runtime to consume the data that is placed into the repository. As the description suggests, this talk will be heavy on code and light on slides.

Code Generation Kathleen Dollard - NET341 -> Material Evaluation Add to my schedule After decades of evolution code generation is ready for an overhaul. New potentials arise as our increasing understanding of code generation converges with changes in Microsoft offerings. You’ll learn core code generation principles that transcend all code generation tools. Building on this you’ll get a dip into template languages seeing both T4 which is part of Visual Studio and VB9 XML literal templates in order to understand the strength of each approach. Once you understand how templates work, you’ll dive into metadata – the part of the system that uniquely describes the specific application your building. You’ll see two approaches to protecting handcrafted code on the .NET platform. And you’ll see how to hook generation into your development process. The overall process of application generation has not matured and is rapidly changing – this talk doesn’t promise silver bullets. Instead you’ll leave with a good understanding of the latest code generation techniques and how you can fit them into your unique development environment.

Conquering XML with LINQ in Visual Basic 9 Beth Massi - NET368 -> Material Evaluation Add to my schedule XML permeates every modern application today including XHTML, XAML, RSS, SOAP, and Open XML, to name just a few. The latest version of Visual Basic in Visual Studio 2008 supports a new language syntax aimed at making you much more productive when working with LINQ to XML. In this session, we'll walk through language features like XML literals, embedded expressions, and axis properties in order to create, query and transform complex XML using LINQ with this powerful but easy to use syntax. We'll also cover tips and tricks and look at other interesting and productive uses of this technology that you may have never thought of before. Say goodbye to XSLT and hello to Visual Basic 9.

Customizing the Entity Framework Model Julia Lerman - NET381 -> Material Evaluation Add to my schedule The Entity Data Model's real power is in its ability to be customized to provide a data schema that YOU want to code and query against, not a schema that is fine tuned by a DBA for performance. If you've only looked at the initial model created by the EDM Wizard, you're bound to be surprised at how dramatically you can impact model. This session will look at both VS2008 and VS2010 to teach you how to implement various types of inheritance, Entity Splitting, Abstract entities and complex types. You will also learn how to do some advanced mapping such as mapping associations as well as digging into the XML to take advantage of QueryViews and Defining Queries. We'll take a look at mapping Stored Procedures in the Entity Data Model and some of the new mapping features in EF4.

Data Sources and Data Binding in WPF Beth Massi - NET369 -> Material Evaluation Add to my schedule Data Sources and Data Binding in WPF Business Applications In this session we'll go over the major classes and interfaces involved in data binding in Windows Presentation Foundation (WPF) clients using a variety of data sources including DataSets and custom object collections. This session will demonstrate the differences in Winforms and the WPF data binding architectures and how you can design your business entities to work well with any Windows smart client. Well also take a look as some of the new WPF drag-drop data binding tooling that will be available in Visual Studio 2010.

Data Visualization Applications with WPF Tim Huckaby - NET337 -> Evaluation Add to my schedule Building Data Visualization Applications with the Windows Presentation Foundation (WPF) This session will be heavily demo focused to accentuate how the power of the Windows Presentation Foundation (WPF) can be used to visualize data. WPF is the next-generation presentation sub-system for Windows. It provides developers and designers with a unified programming model for building rich Windows smart client user experiences that incorporate UI, media, and documents. WPF uses vector based graphics rendering, which results in better graphics and presentation for an application. WPF also has other features such as layout, styling, and data binding, which, when you mix with interactivity, enables scenarios such as interactive data visualization. When you put all this together, you have a unified API for various presentation components, such as 2D and 3D documents and declarative programming through XAML, which is a powerful platform for data visualization that can be used to really “light-up” you enterprise applications. WPF is manifested in 3 major application platforms (Windows Client, Silverlight & Microsoft Surface) and all will be covered in this session at some level.

Declarative UI Programming with XAML Tim Huckaby - NET233 -> Evaluation Add to my schedule Declarative UI Programming with XAML: WPF, Silverlight & Surface XAML has become the de facto declarative language for UI development on the Microsoft platform spanning Windows, Web and the Microsoft Surface. This transformation to a single declarative language for all platforms has enabled Microsoft to deliver on the bold promise of a cross platform user experience programming model for the future. In this unique session we take a look at how knowledge of XAML and .NET languages like C# and VB.NET allow you to develop applications for Windows (WPF), the Web (Silverlight) and the Microsoft Surface using the same coding constructs and idioms. In this demo packed session we will take a look at how graphics, animations, data binding, styles and templates are commonly implemented on these platforms and how XAML makes all of this possible.

Expression Blend to Build World Class WPF App. Kevin McNeish - NET262 -> Material Evaluation Add to my schedule Working with Expression Blend to Build World Class WPF application Expression Blend is the tool of choice for building both WPF and Silverlight front ends. This session takes an in-depth look at Expression Blend's many features including animations, data binding, user interface layout, and so on, to give you the information you need to get productive immediately using this excellent UI design tool. You will also see how it's possible to use Expression Blend to create a single user interface that can be used in both WPF and Silverlight

Future Directions for Microsoft Visual Basic and C Beth Massi - NET383 -> Material Evaluation Add to my schedule Microsoft has decided to Co-evolve their premiere .NET languages, Visual Basic and C#. In this session you will gain insight into language team's strategy and direction for implementing new features. You'll also learn about the new capabilities of the next version of the languages, including additional productivity features, syntax simplifications, and a host of other improvements.

Implementing Microsoft Virtual Earth in Your ASP.N Jim Duffy - NET302 -> Material Evaluation Add to my schedule In this session attendees will learn how to add mapping capabilities to their ASP.NET applications utilizing Microsoft Virtual Earth. This demo intensive session will explain how to integrate and programmatically control the Microsoft Virtual Earth service. Topics covered include displaying a default map, displaying a specific map, how to zoom and pan, working with the navigation controls, adding custom controls, adding shapes and plotting specific points, importing GEORSS data, selecting road, aerial or hybrid displays, working with map events, and working with bird's eye view images. From displaying sales hotspots to providing driving directions, if you've ever wanted to know how to add interactive mapping features and capabilities to your web applications this session is for you.

Integrating Virtual Earth and SQL Server 2008 Jim Duffy - NET303 -> Material Evaluation Add to my schedule In this demo intensive session attendees will learn how to use Virtual Earth to leverage SQL Server 2008's new spatial data types, geometry and geography. This session will demonstrate how to use Virtual Earth to display the results of spatial data queries as well how to save spatial information created by user interaction in Virtual Earth. If you are interested in learning how to retrieve, display, and update spatial (latitude and longitude) data using Virtual Earth and SQL Server 2008 this session is for you.

iPhone Development for .NET Developers Kevin McNeish - NET384 -> Material Evaluation Add to my schedule This session introduces .NET developers to the tools and technologies available for building applications that run on the iPhone platform. It compares and contrasts Visual Studio with the Xcode development environment and demonstrates the basics of building a simple application that runs in the iPhone simulator and can be deployed to an actual iPhone device

Microsoft Concurrency and Coordination Runitme Ranjan Sen - NET332 -> Material Evaluation Add to my schedule Present DSS/CCR available in Microsoft Robotics Studio and DSS/CCR Toolkit. Illustrate the asynchronous decentralized programming model will examples and demo. Illustrations are using C#.

Microsoft Parallel Processing Technologies Ranjan Sen - NET331 -> Material Evaluation Add to my schedule Introduce the Parallel Computing Initiative at Microsoft along with the range of language extensions, libraries, tools, development suits, server platforms suitable for addressing the multi-core, multi-core and server cluster based program development. Provide demos of using Task Parallel Library (TPL) using C# and Parallel Patterns Library (PPL) for C++. Visual studio 2010 debugging and profiling tools for parallel program development

Objective-C for .NET Developers Kevin McNeish - NET289 -> Material Evaluation Add to my schedule This session compares the Objective-C language with the .NET C# language, focusing mostly on the object-oriented language features including declaring classes, inheritance, interfaces, polymorphism, memory management, and design patterns such as Model-View-Controller, Chain-of-Responsibility, and Delegation

Refactoring with Generics Kathleen Dollard - NET339 -> Material Evaluation Add to my schedule Generics open up new opportunities to increase the robustness of your code, improve its performance, and significantly reduce the total amount of code you write. After a brief introduction to generic syntax, Kathleen will show you how using generics improves the quality of your code. You’ll see how easy it is to shift your current collections to generic collections and learn how LINQ takes advantage of generic enumerable sets. You’ll learn how to write your own generic methods and classes. You’ll see how to leverage the spectrum of generic possibilities in a business object hierarchy that reduces the total lines of code by about 50%! Finally we’ll take a deep dive into nuances of generics, such as their relation to shared data, layered generics, reflection, and lambda expressions You’ll walk out of this talk understanding how to use generics to improve your own applications.

So You're Finally Getting Into WCF Miguel Castro - NET254 -> Material Evaluation Add to my schedule Stop using Web Services and Remoting! OK, now that I got your attention let’s get serious. These two technologies are all but dead. You need to start learning WCF if you haven’t already. It’s the platform for all connected applications going forward, and you know what? It’s significantly easier to use than you think. In 75 minutes, I’ll teach you what you need to know to hit the ground running with Windows Communications Foundation. Don’t miss it!

Visual Studio Debugger Tips & Tricks John Bristowe - NET343 -> Material Evaluation Add to my schedule The Visual Studio Debugger provides a slew of features that make the task of debugging both easier and more efficient. Learn about time-saving tips and tricks for all versions of the Visual Studio Debugger, including the new debugger features in Visual Studio 2010. Hear about the new mixed-mode debugging feature, the breakpoints window enhancements, the new WPF visualizers, and a number of other features. Also learn about thread debugging enhancements, new features for making stepping into properties easier, and more. Join us as we crack open the toolbox and walk through some of the debugger's best practices.

WCF and WF, Like Birds of a Feather Rob Daigneau - NET392 -> Material Evaluation Add to my schedule We all know that WCF is Microsoft’s technology for the creation of WS* and RESTful services. Then there’s WF for workflow modeling and development. These two technologies go together like, well you know, peanut butter and jelly. Join us in this session to see how to create WCF services that leverage WF in order to invoke asynchronous long-running processes. If time allows, we’ll also peer into the future to see what .Net 4.0 will bring to the table.

What’s New in Entity Framework .NET 4 aka EF4 Julia Lerman - NET202 -> Material Evaluation Add to my schedule Have you been waiting with anticipation for Entity Framework v2? Well, it’s now called EF4 and it is finally here to play with in the recently released VS2010/.NET4.0 Beta 1. In this session, Programming Entity Framework author, Julie Lerman will give you a lap around the new bits. We’ll take a look at the much improved EDM Designer, T4 code generation, the lazy loading implementation, query compilation improvements, model-first design, the new ObjectSet class, new methods that will help with n-tier development and the much anticipated POCO support for agile and test driven development. We’ll also talk about some of the features that didn’t make it into the Beta 1 but will be coming soon, such as Foreign Key support.

A Deep Dive into the ASP.NET AJAX UpdatePanel Rob Windsor - NET328 -> Material Evaluation Add to my schedule The ASP.NET AJAX Extensions, which provide the core AJAX functionality, include a control called the UpdatePanel which allows developers to add AJAX-like functionality to a page. By wrapping portions of ASP.NET pages in an UpdatePanel, you automatically transform postbacks originated by page controls to lightweight, AJAX postbacks. In this session we will do a thorough examination of the UpdatePanel, going from the basic uses to interacting with requests from client-side JavaScript. The demonstrations include: an introduction to the UpdatePanel, using external triggers, using the UpdateProgress control, handing multiple postback requests, and handling server errors.

AJAX 4.0: Rich Internet Applications Come of Age Don Kiely - NET465 -> Material Evaluation Add to my schedule The ASP.NET team at Microsoft just never sits still. They are enhancing the AJAX features of ASP.NET with great new stuff like client-side template rendering, declarative instantiation of behaviors and controls, a DataView control, markup extensions, and new bindings. Everything is in flux, but there are few parts of ASP.NET as exciting as what is coming down the road. During this session we’ll explore these new features as implemented in the current release and see how you can make your Web applications an even better experience for users. Microsoft’s plans for AJAX will blow your mind!

ASP.NET AJAX Tips and Tricks Rob Windsor - NET375 -> Material Evaluation Add to my schedule The combination of Visual Studio. the .NET Framework 3.5 and the ASP.NET AJAX extensions give you very powerful tools for building rich, interactive web applications. In this session we will discuss how to effectively use these tools with a specific focus on making the development experience faster and easier. We'll take a look at the intellisense and debugging features of Visual Studio 2008, how to utilize script-callable web services, how to use the ASP.NET History feature to manage browser history, how to use the Membership and Profile systems from client-side JavaScript, and how to use jQuery with ASP.NET AJAX,.

ASP.NET Dynamic Data John Bristowe - NET358 -> Material Evaluation Add to my schedule ASP.NET MVC contains a new scaffolding feature based on Dynamic Data that provides a rich framework for creating data driven web sites. Learn how to quickly build a Dynamic Data web site using features like model level validation, field and entity templates, and scaffolding.

Building custom web app. with the Sitefnity Adam Crandall - NET325 -> Material Evaluation Add to my schedule Presented By Adam Crandall and Sing Chan Sitefinity is a development platform for construction and management of websites, community portals, and intranets. Inspired by Web 2.0 UIs, the product delivers top experience for end users, while the flexible architecture empowers developers to be in a full control. In this presentation will create a new Sitefinity website and build a cutom application leveraging Sitefinity, it's extensive API and the .Net framework.

Data in the Cloud Shawn Wildermuth - NET301 -> Material Evaluation Add to my schedule Storing data outside the data center is not a new concept. But with the introduction of Microsoft's Azure and Amazon's SimpleTable platforms, storing your data in a available/scalable way is becoming easier. In this talk I will discuss the storage model for these services and how you can determine what data you can trust in the cloud.

Death of a Web Server: Crisis in Caching Richard Campbell - NET318 -> Evaluation Add to my schedule Our web servers don't tell us what's wrong, they just fail and it's up to us to figure it out. In this session you'll watch the diagnosis of a failing web site under load. The load test will be live and the servers will fail as you watch. You'll learn how to instrument a web site to understand the failure. Then you'll learn how to diagnose the failure and evaluate the solutions - whether to change code, alter configuration, add hardware or more. If you've ever had to answer the question "Why is the web site so slow?" this session is for you!

From One Web Server to Two: Making the Leap Richard Campbell - NET345 -> Evaluation Add to my schedule Every web application starts out on a single web server. And while we've been told over and over again that you can always move to multiple web servers, it's not as simple as that! This session digs into the details of what it takes to make that leap - all the changes needed to let your application function properly with more than one server. You'll learn about replicating your web application between two servers and how to keep the content in sync. The techniques and challenges of load balancing are explored. And you'll explore the critical challenge of moving to multiple servers - getting rid of affinity. There's more affinity than just the session object, but that is a key starting point. Moving to multiple servers isn't easy, but this session will give you the check list of what to do to be successful.

Fun with HTTP Handlers & Security Miguel Castro - NET387 -> Material Evaluation Add to my schedule Want to learn how all about handlers and produce something useful at the same time? I’ll show you how to write both DLL based handlers and ASHX handlers while at the same time showing you how you use them to protect and/or track file downloads on your sites. This one will be cool and fun, and you have commercial software to sell, you do not want to miss it.

Integrating ASP.NET AJAX with SharePoint 2007 Rob Windsor - NET352 -> Material Evaluation Add to my schedule SharePoint provides a great infrastructure for quickly building intranet and Internet applications. ASP.NET AJAX provides a foundation for creating highly productive Web interfaces. Combined they are two great tastes that taste great together! In this session we will cover how to get started working with ASP.NET AJAX inside of SharePoint 2007. We will take a look at how to prepare a Web Application for ASP.NET AJAX, and how to use various ASP.NET AJAX tools such as the ScriptManager and UpdatePanel controls, JSON-enabled Web services, and the AJAX Control toolkit to add rich interactivity to your SharePoint sites. Attendees of this session should be familiar with WSS 3.0 development and to have had some exposure to ASP.NET AJAX.

Integrating MS Outlook 2007 and MOSS Yaroslav Pentsarskyy - NET456 -> Material Evaluation Add to my schedule In many organizations SharePoint has become one of the most common collaboration tools. There is still, however, a habit of users trying to collaborate using Microsoft Outlook - sending versions of documents to one another. In this session, we'll look at how you can integrate Microsoft Outlook 2007 and MOSS 2007 so that users can save their email attachments to predefined document library or their “My Site”. This powerful example will also uncover many other integration capabilities between MOSS and other MS Office 2007 applications. Having a convenient integration, users in many organizations will see more benefits in utilizing MOSS for their daily tasks. Participants will be supplied with the sample allowing them to implement the solution in their work environment.

jQuery 101 Rod Paddock - NET101 -> Material Evaluation Add to my schedule Web 2.0 is here to stay. jQuery is a javascript library that abstracts away all of the gory details of working with Javascript for web applicatons. This session will demonstrate how to added Jquery to your ASP.NET applications today. This session will focus on proper uses of Jquery including how to organize your javascript code, how to use selectors in Jquery. How to manipulate your web content dynamically. Along with uses of the standard Jquery library time will also be spent exploring some of the most useful Jquery plugs ins.

Leveraging Telerik Web Controls In Your SharePoint Shereen Qumsieh - NET351 -> Material Evaluation Add to my schedule Telerik currently offers a full suite of powerful UI controls which seamlessly integrate into SharePoint and help developers build feature rich and highly responsive user interfaces for MOSS and WSS. In addition to their standard suite, Telerik offers a free version of the built in rich text editor that is cross browser compatible and offers support for the macintosh platform. This session will walk you through the steps for building SharePoint Web Parts and Custom Application Pages with specific code examples that leverage Telerik to provide a richer end user experience. We'll cover a specific subset of the Telerik Web Controls including: RadGrid, RadComboBox, RadAjax and RadCalendar and I'll also demonstrate briefly how to setup the Telerik RadEditor for SharePoint.

Leveraging the Power of jQuery in ASP.NET Web Appl Sing Chan - NET355 -> Material Evaluation Add to my schedule jQuery is a lightweight, open source, JavaScript library and is one of the most popular DHTML/AJAX libraries on the web. Now that Microsoft is making jQuery part of its official development platform, find out how you can integrate the power of jQuery in your web applications. Learn how to: • enable Intellisense for jQuery in Visual Studio 2008 • leverage jQuery’s elegant and efficient selector API to query for HTML elements and apply commands to them • integrate jQuery with your web applications that already incorporate ASP.Net AJAX

SharePoint 2007: A Developers Primer Rob Windsor - NET334 -> Material Evaluation Add to my schedule SharePoint is an awesome tool. It allows you to build web sites, manage lists of data, collaborate on documents, and so much more – all done through a simple, easy to use, web interface. When you need to go beyond the built in capabilities of the product, SharePoint also provides a rich set of APIs to code against. This session explores the most commonly used features in the Windows SharePoint Services developer APIs, as well as the types of components and applications in which they can be utilized. Topics covered include the WSS object model, WSS web services, creating simple web parts, and adding event handlers to lists.

SharePoint Development Tips and Tricks Sherman Woo - NET321 -> Material Evaluation Add to my schedule This session will take a look at the many tools, utilities, and source code found around the web. The tools help make our SharePoint Developer's lives easier, and the many source code samples help us learn and grow. The session will focus on a lot of demos, working within Visual Studio 2008 and also showcasing a few tools that SharePoint developers shouldn't live without.

Understanding ASP.NET Under the Covers Miguel Castro - NET374 -> Material Evaluation Add to my schedule In my humble opinion, nothing makes you a better developer than truly understanding how something works beyond the superficial. We all know ASP.NET as the great framework and development environment for delivering web applications; but do you truly know what happens, in detail, from the moment you request an ASPX page to the moment the HTML is served? A lot of this is the web control architecture that resides at the very heart of ASP.NET, and a lot of is based on the fact that ASP.NET is designed for so much more than just serving pages. In fact, learning how controls work is learning how ASP.NET works. In this session, I’ll step through the process from the moment you type your URL to the point where you see the page on your browser and every step in between. While you learn and understand this roadway that is the ASP.NET architecture, you’ll see how it is capable of handling many other things besides web pages. This session is for the beginner who is new to ASP.NET as well as for the advanced developer who simply wants to get more intimate with how it truly does what it does. Learn about controls, handlers, modules, page parsing, request, response, etc. This is not new MVC, or bleeding edge Silverlight. No egos here, just a terrific appreciation for understanding the ins and outs of something that has successfully let you deliver great web applications for 8 years now; in my opinion, a prerequisite for anything else we do with Microsoft tools on the web today.

Advanced Usages of Inversion of Control Containers Oren Eini - AGI477 -> Evaluation Add to my schedule You already understand the concepts of Inversion of Control and Dependency Injection, now is the time to see how far we can make the IoC container works for us. This talk will focus on using an IoC container in complex scenarios. We will talk about generic decorator chains and generic specialization, contextful containers and IoC DSLs. These powerful concepts can greatly enhance your ability to respond to change in your application.

Agile Q&A with Dave Laribee and Friends David Laribee - AGI291 -> Evaluation Add to my schedule Join Dave Laribee - Agilist and software entrepreneur - for an Agile talk on Agile. Challenge Dave and a panel of Agile experts speaking at DevTeach to provide actionable answers about eXtreme Programming practices such as TDD/BDD, pair programming, continuous integration, and collective ownership. Have a question about Scrum or release planning? Need to know how to integrate QA into the Agile delivery model? Participants drive content by suggesting a list of topics, prioritizing them, and voting a covered subjects done as we fuse a fast-paced and rolling panel discussion with an XP-style planning game.

Are Agile and Domain Modeling Frenemies? Michael Stiefel - AGI355 -> Material Evaluation Add to my schedule Are Agile and Domain Modeling Frenemies? Can They Work Together? Advocates of agile development often claim to use domain modeling when building software. Yet there are some serious conflicts in approach between the two. Agile developers often deprecate explicit design work. Yet domain models cannot be just built on the fly. Since both approaches have a great deal to offer, this talk explores how to get them to work together.

Behavior-Driven Development Installed David Laribee - AGI233 -> Evaluation Add to my schedule It’s been said that BDD is TDD done right, but what does that really mean? In this introductory survey we'll take look at the one-two punch of User Stories and Behavior-Driven Development as a critical link in the Agile value chain. First, we’ll understand what makes a good user story and share techniques for authoring and managing them. We'll take a deep dive on writing some acceptance criteria and scenarios. Armed with this foundation, we'll examine how BDD is used to turn a story into working software and compare BDD to the more-established and better-known process of Test Driven Development. Some consideration will be given to tools such as NBehave, RSpec, Rhino Mocks and the AutoMockingContainer. If you're looking for specific examples and code, this is a session for you!

Convention-over-Configuration in a .NET World James Kovacs - AGI321 -> Material Evaluation Add to my schedule As developers, we spend an inordinate amount of time transforming objects from one representation to another... view-models or DTOs to domain objects... domain objects to database rows... Wouldn't it be nice if this could happen automagically for us? This session will look at using convention-based approaches in Fluent NHibernate and AutoMapper to do exactly that!

Domain Driven Design Chalk Talk Greg Young - AGI376 -> Evaluation Add to my schedule We as developers and designers face increasingly more difficult problem spaces. By creating models around these problems we can create better, more flexible, longer lasting, and further distilled solutions to these problems. Domain-Driven Design is a formalization of this process. This talk introduces many of the basic patterns in Domain-Driven Design but instead of focusing on the patterns themselves it focuses on the interactions and intentions of the patterns. In other words, we will talk about "entities" for about 30 seconds before we get down and dirty on some real life problems and handle the tough stuff like determining aggregate boundaries and the roles of application services. A novice should be able to take away something from this talk, but then again so should an expert.

Done Done Erik Renaud - AGI397 -> Material Evaluation Add to my schedule Duo with Francois Tanguay Come hear Erik & François talk about what it means to be finished. On traditional 3 year projects, everyone knows when it’s done. How do you define this on a agile project, when you never know when the client will stop asking for new functionality ? What do we

Getting to Release-per-Feature with Lean David Laribee - AGI284 -> Evaluation Add to my schedule What if we could release a feature to our customers as soon as it was completed? Challenges such as code that in progress make this difficult, but if we could get there we'd reap the benefits of faster return on investment and shorter feedback between customer and developer. In this talk we'll examine the tactics behind release-per-feature. We'll survey process tools from the Lean Software Development movement: Kanban and Value Stream Mapping. We'll also delve into the technical, looking at branching strategies and composite applications.

Getting Your Mind Around TDD Claudio Lassala - AGI249 -> Evaluation Add to my schedule Even though the name suggests that Test-Driven Development (or TDD) is all about testing code, it is actually more about designing the code. By following TDD, a developer writes code that is well designed, tested, and documented, and therefore, the quality of what is produced is much higher then that of a code-and-fix approach.

Inversion of Control Containers Hamilton Verissimo - AGI332 -> Evaluation Add to my schedule Inversion of Control Containers: it is all about isolation There are plenty of IoC Containers nowadays. Some promise to 'fix' your design, to increase testability and so forth. Let's take a step back and see from where the IoC Containers came from, their main goals, the concepts involved and how they simplify (or not) some design decisions.

Isolating Dependencies in Tests Using Mocks Claudio Lassala - AGI354 -> Material Evaluation Add to my schedule Isolating Dependencies in Tests Using Mocks and Stubs Soon after getting used to writing "unit" tests, developers tend to realize that those tests weren't really testing "units"; they were testing way more than that. In order to write real unit tests, it's necessary to use test doubles such as mocks and stubs. This session covers how to create and use those, and how to use Rhino Mocks to simplify things further. As we learn about those things, we'll also learn about the importance of thinking through how we write our code, putting thought into the dependencies that a class may have, and how things should be split up.

Light Up Your Apps with IoC Conventions James Kovacs - AGI347 -> Material Evaluation Add to my schedule Inversion of Control (IoC) containers, such as Castle Windsor, increase the flexibility and testability of your architecture by decoupling dependencies, but as an application grows, container configuration can become onerous. We will examine how convention-over-configuration can allow us to achieve simplicity in IoC configuration while still maintaining flexibility and testability. You can have your cake and eat it too!

ORM+=2: More Than Just Data <-> Objects Oren Eini - AGI432 -> Evaluation Add to my schedule Object relational mapping are becoming only more popular, as people developing complex systems find that they need more than the tabular model to work with in their applications. A sophisticated ORM can do a lot more than merely get the data out of the database in object form, it can be a valuable assest in simplifying development and making things possible. In this session, you will see how you can utilize an ORM in untraditional ways to get an additional, better, approach to solving complex issues. Some of those ways include business rules, localization, state transitions, inversion of control, etc. All done via the ORM layer, and all can be used to drasticly simplify the complexity of the given scenarios.

Producing Production Quality Software Oren Eini - AGI244 -> Evaluation Add to my schedule Working software is no longer the only thing that we need to produce. We need to create a software system that has a chance of surviving in the cruel world of production system, outside the clean room and sterile environment of development and QA. Understanding bottlenecks in the system, preventing cascading failures and recovery strategies have ceased being the problems of the very high end players. With the cost of system downtime being measures in $$$/second, this is an area we have to consider all the way. In this talk we will cover how we can map common weaknesses in the system design, preemptively protect ourselves from them, and produce software systems that can withstand the real world hostile environment.

Releasing To Production Every Week Owen Rogers - AGI329 -> Evaluation Add to my schedule Delivering more value faster is the mantra of every software team; however, new features don't start to deliver value until they are running in production. Compressing release cycles without compromising quality is the key to increasing value. For the past year, my team has been following an agile process that allows us to consistently deploy new releases into production every week. In this session, I'll talk about the lessons learned, the tools we use and the process we follow.

The Importance of Confidence in Development Donald Belcham - AGI387 -> Evaluation Add to my schedule During the life of a software development project confidence issues can arise. Developer, management and client confidence in the code or in each other are normal to find. What tooling, processes and practices can we, as professionals, bring to projects to increase the confidence of all parties involved? How can these tools and techniques integrate on greenfield and brownfield projects? Software development is much more than a challenge of technical problem solving. It’s also a discipline that requires you to be aware of the interaction between different components of the project team and its deliverables. Mitigating the risk of failures in confidence can be accomplished through the prudent use of existing and tried techniques. This session will look at some of those techniques and discuss how and where they will lead to increased confidence for both the technical and non-technical members of the project.

User Stories, Iterations, and Releases David Laribee - AGI278 -> Evaluation Add to my schedule Agile projects revolve around user stories. User stories are the artifact that enables functional specification of the application, project management, and estimation and planning of the work. User stories also provide the starting point for acceptance test-driven development. They are the central, unifying tool that gets everything started and keeps it going. This session covers writing user stories, expressing acceptance criteria, story estimation using fibonacci numbers and story points, as well as release planning, iteration planning, and retrospectives.

Writing Domain Specific Languages in Boo Oren Eini - AGI374 -> Evaluation Add to my schedule Domain Specific Langauge is not just the DSL SDK from Microsoft. A DSL can make working with the domain much easier, since you are capable of leveraging the domain concepts directly. The other alternative to a DSL is an XML file, and we all know how well declarative model can work when you need imperative concepts, just consider NAnt for a minute and you will see the issue. Usually, writing a DSL in .Net would be a complex issue, requiring writing a parser, interpreter, etc. Boo already handles all of that, and its open architecture means that it is very easy to extend it to express the concepts of the domain. This talk will show you how to build DSLs in Boo and how to utilize this power in your applications.