Community Events

Français · Montreal, March 29, 2010 21:50 ET
 
   


Carl and Richard look back on the last year joined by a cast of former guests and conference speakers in the hotel bar at the Marriott Chateau Champlain in Montreal while at DevTeach. WARNING: Unbleeped F-Bombs!


The sessions list is completed at 96%


Agile Track

Agile Estimation
Joel Semeniuk - AGI233 -> Material Evaluation Add to my schedule
How do you estimate you projects today? Stick your finger into the wind? Yesterday's weather? Chaos theory? WAG? Spidey senses? In this session we'll explore a number of different estimation techniques you can use on your projects. We will also take a look at some tools you can use to help with your estimation processes.

Being an Agile .NET Consultant
Peter Ritchie - AGI372 -> Material Evaluation Add to my schedule
Thinking of making the leap to consulting and want to stand above the crowd with your ability to deliver? See how becoming agile can help you deliver to your clients faster and better than other consultants, regardless of the client's process.

Convention-over-Configuration in an Agile World
James Kovacs - AGI371 -> Material Evaluation Add to my schedule
As developers, we spend an inordinate amount of time writing "glue code". We write code to transform database rows to domain objects... domain objects to view-models or DTOs... We write code to configure inversion of control containers and wire dependencies together. We write code to style our UIs and respond to UI events. Wouldn't it be nice if this could happen automagically for us? This session will look at using convention-based approaches using Fluent NHibernate and Castle Windsor to reduce the amount of repetitive code and accelerate application development. Check out Convention-over-Configuration in a Web World in the Web Track to learn about applying these techniques to AutoMapper and jQuery.

Dependency Inversion Principle
Donald Belcham - AGI367 -> Evaluation Add to my schedule
An Introduction to the Dependency Inversion Principle and Inversion of Control Containers

As the .Net developer community continues to evolve, more emphasis is being put on creating applications that are easily maintained and quick to modify. One of the easiest techniques for accomplishing this is to strive for highly decoupled code. As a result, more projects are looking to make use of the Dependency Inversion Principle (DIP) and Inversion of Control (IoC) containers. In this session we will look at the concepts behind DIP as well as a decoupled implementation of an IoC container using Castle Windsor.

Kanban and Scrumban
Joel Semeniuk - AGI345 -> Material Evaluation Add to my schedule
The Japanese word kanban is a common term meaning "signboard" or "billboard" - and as of recently has been influencing Agile development practices around the world. Come and find out what Kanban is and how you might be able to use it on your Scrum projects.

ORM Fundamentals
Donald Belcham - AGI349 -> Evaluation Add to my schedule
What is ORM (Object Relational Mapping) and what does it have to do with your applications? Come to this session to find out! We'll explain what ORM is meant to do, and go over the available tools like Entity Framework and NHibernate. If you've ever wondered what all the buzz is about with ORM, this is the session for you!


Web development

A Lap Around ASP.NET 4.0
Rob Windsor - NET320 -> Material Evaluation Add to my schedule
There are a significant number of changes for web developers in Visual Studio 2010 and .NET 4. Visual Studio offers new project templates, markup snippets and integrated web deployment features. WebForms adds routing, greater control of client identifiers, and easy integration between the data controls and dynamic data. ASP.NET AJAX gets a new name and adds client templates, the observer pattern, and jQuery out-of-the-box. Finally ASP.NET MVC is getting a whole new version. In this demo heavy session we will cover and many of these new features as time allows.

Convention-over-Configuration in a Web World
James Kovacs - NET353 -> Material Evaluation Add to my schedule
As developers, we spend an inordinate amount of time writing "glue code". We write code to transform database rows to domain objects... domain objects to view-models or DTOs... We write code to configure inversion of control containers and wire dependencies together. We write code to style our UIs and respond to UI events. Wouldn't it be nice if this could happen automagically for us? This session will look at using convention-based approaches using AutoMapper and jQuery to reduce the amount of repetitive code and accelerate application development. Check out Convention-over-Configuration in an Agile World in the Agile Track to learn about applying these techniques to object-relational mapping and IoC container configuration.

From 1 Server to 2: Making the Leap to Web Farms
Richard Campbell - NET399 -> Evaluation Add to my schedule
From One Server to Two: Making the Leap to Web Farms

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.

Get a WIF of this
Colin Melia - NET345 -> Evaluation Add to my schedule
Writing services that understand multiple authentication systems is cumbersome and completely yesterday. Claims-based authentication and authorisation is the way to go. We'll take a dive into how claims work and what Windows Identity Foundation provides by exploring the key components, but more importantly by building our own identify provider, a claims-based service and a Silverlight application that makes use of it.

Just Add Kung Fu with ASP.NET MVC v2
Colin Bowern - NET394 -> Material Evaluation Add to my schedule
Roll up your sleeves and get ready to code as we look at going beyond hello world into how ASP.NET MVC v2 supports building larger applications by addressing maintainability, productivity, and validation gaps. In this session you will see how areas, helpers, and data annotation help you can roll ASP.NET MVC v2 into your work today through integrating or augmenting existing applications. You will walk away with ideas that you can start with the minute you get back to the office.

Maintainable & Modern JavaScript
K. Scott Allen - NET391 -> Material Evaluation Add to my schedule
In this session, we’ll cover the JavaScript fundamentals you need to know for writing maintainable script and making the most of the latest JavaScript libraries. We’ll cover prototypical inheritance, functional programming, closures, unit testing, and demonstrate unobtrusive JavaScript. Along the way, we’ll see many popular paradigms for JavaScript, and explore the capabilities of this unique and dynamic language.

The Azure Whirlwind Tour
Colin Melia - NET456 -> Evaluation Add to my schedule
The Azure Whirlwind Tour: An Application from the Ground to the Cloud

The Windows Azure Platform contains a lot of untamed capabilities. Understanding its features and how they can be used is key to harnessing and directed their power. In this whirlwind tour, we’ll take a look at building an app and we’ll touch down on elements like Windows Azure, Windows Azure Storage, SQL Azure, AppFabric Service Bus, AppFabric Access Control, PowerShell control, Diagnostics and of course the Windows Azure Platform portal. This session may go broad… and high.

Using Dynamic in C# to do Amazing Things
Aaron Erickson - NET453 -> Material Evaluation Add to my schedule
In this talk, we focus on the only new feature in C# 4 that really matters — the dynamic keyword. There are some new, amazing possibilities that, previously, were only elegantly achievable with dynamic languages like JavaScript and Ruby. We will touch on ways that using dynamic can change the way that you code, including things like a true ActiveRecord pattern, Expando objects, and more.

Using jQuery to deliver a Rich Interactive
Kelly Cassidy - NET349 -> Evaluation Add to my schedule
Using jQuery to deliver a Rich Interactive Web Experience

Although there are many ways to deliver rich Internet applications, jQuery is a library that can be used to deliver the experience using only HTML, CSS and JavaScript. Being one of many web-based libraries, jQuery is one of the most popular and contains a number of plugins that can enhance your website with an amazing user experience. We'll cover cross-browser development as well as mobile development and we'll also compare jQuery to other JavaScript-based libraries out there.

Using Modern development technologies with CRM
Shan McArthur - NET377 -> Material Evaluation Add to my schedule
Linq, ADO.NET Data Services, WCF RIA Services, AJAX and Silverlight: Using Modern development technologies with Dynamics CRM

Soap-shmope - CRM developers can use the latest development technologies such as LINQ, ADO.NET Data Services, AJAX, and Silverlight. With more code than slides, developers will see working examples of how to easily build applications that connect to Dynamics CRM using modern development technologies. The session will demonstrate where each of these technologies can be used with CRM effectively and give architectural guidance in the areas of scalability and security.


Windows Development

Advanced Refactoring with Visual Studio 2010
Peter Ritchie - NET392 -> Material Evaluation Add to my schedule
Thought refactoring was more than just renaming, changing parameters, extracting an interface, and encapsulating a field? Delve into real-world examples of every-day refactorings including: refactoring to patterns like MVP, ; refactoring Code Smells, refqactoring to principles like Single Responsibility, Dependency Injection, and Interface Segregation. Includes automated testing ensure quality.

Advanced Windows PowerShell Scripting
Edwin Sarmiento - NET366 -> Material Evaluation Add to my schedule
If you've been working with Windows PowerShell for a while and are looking to go deeper, come learn about some of the more advanced PowerShell features that will help take your scripting skills to the next level. We cover sophisticated automation techniques such as transactions, jobs, remoting, custom sessions, advanced functions, and modules, among others.

Extending Microsoft Office with Visual Studio Tool
Shaun Hayward - NET361 -> Evaluation Add to my schedule
Visual Studio Tools for Office allows you to build custom solutions that run on top of Microsoft Office products using Visual Basic or C#. For anyone who has ever said, ""I wish Excel could..."" Visual Studio Tools for Office is your solution. Take advantage of the power of Office and don't rewrite a word processor for your solution. Topics include an overview of Visual Studio Tools for Office, creating new Office add-ins and adding controls to the Office Ribbon. Three (3) working (but easy-to-understand) examples will be given. Excel Add-in to pull data from Ole Db data sources for times when managers ask, ""Could you put this in Excel for me... every week."" PowerPoint Add-in to build an instant slideshow for Karaoke night. Word Add-in to transpose guitar chord sheets - great for musicians. Familiarity with C# assumed, although VB programmers should have no problem understanding and applying knowledge gained from the talk. Uses Visual Studio 2010 and Office 2010, although Visual Studio Tools for Office is available for Office 2003 and 2007 using Visual Studio 2005 and 2008.

Indexed LINQ in Windows Applications
Aaron Erickson - NET432 -> Material Evaluation Add to my schedule
Implementing the Concept of Indexed LINQ in Windows Applications

We all know to optimize last. But that time comes when, of course, that "last" moment arrives! In this talk, we cover what "Indexed Linq" is, when to use it, and the i4o open source project, which easily allows you to implement this type of optimization.

LINQ: De-Mystifying the Compiler Magic
Jonathan Aneja - NET385 -> Evaluation Add to my schedule
Interested in how LINQ actually works, under the covers?  In this session we’ll take a close look at the VB and C# language features that enable LINQ: Query Expressions, Type Inference, Anonymous Types, Extension Methods, Lambda Expressions, Closures, and Expression Trees.  Step-by-step we’ll walk through how the compiler actually decomposes a query expression, and you’ll see how you can use these features in your own code.  By the end you’ll be able to dazzle your coworkers as you explain concepts like anonymous type mutability, deferred execution, and how to write your own LINQ query operators.  You’ll even learn how to dynamically construct a LINQ query at runtime!  Instead of slides we’ll spend most of our time coding (demos will use LINQ to Entities - half in VB, half in C#).  By the time you leave this session, you’ll have a clear understanding of how queries and the individual language features can be powerfully leveraged in your own applications to write less code.

Optimizing Procedural Code
Kimberly L. Tripp - SQL345 -> Material Evaluation Add to my schedule
SESSION: Understanding how stored procedures are created, stored, compiled/optimized and executed is critical for any application that uses them. It might seem simple that a created stored procedure would be compiled and that subsequent executions would leverage the procedure's compiled plan but the compiled (and optimized) plan may not be good for ALL executions. In this session I will show you how to know when stored procedures plans should not be saved as well as your MANY options that exist to achieve better and more consistent performance.

Overview of the Entity Framework 4.0
Jonathan Aneja - NET324 -> Evaluation Add to my schedule
Come see how the ADO.NET Entity Framework enables new capabilities to leverage multiple development approaches, for example the use of code-first, model-first, and database-first. Hear how, regardless of the development approach, developers will benefit from the Entity Framework and the deep integration with the rest of the Microsoft .NET Framework 4, such as the Microsoft ASP.NET MVC, Dynamic Data, and Windows Presentation Foundation. Areas covered include: • POCO support • Better N-Tier API support, and the Self-Tracking Entities (STE) template • Foreign Key Association support • Enhanced TDD support

The Windows API Code Pack
Kate Gregory - NET343 -> Material Evaluation Add to my schedule
The Windows API Code Pack: Your Shortcut to Windows 7 Development

This session will drill in to the features provided by Windows 7 and how to add them to your application using the Windows® API Code Pack for Microsoft® .NET Framework. Samples in both Visual Basic and C# will cover shell integration (taskbar, previews, and more), restart and recovery, power awareness and more. Learn how to add your own tasks to a jumplist taskbar, to recover from a reboot or a crash without losing any user data, and to modify your application’s behavior to conserve battery power. When you leave this session you’ll be ready to transform the user experience your application provides and take full advantage of Windows 7.

Be sure to attend the Lighting Up session (earlier the same day) for inspiration and ideas about the Windows 7 features you will want to implement.

Tips and Tricks for Proper SQL Server Table Design
Kimberly L. Tripp - SQL355 -> Material Evaluation Add to my schedule
SESSION: If your application includes a SQL Server database then you've had to choose some data types and design some tables. But how can you tell whether the design you chose helps or hinders SQL Server as it stores and processes your data? Paul used to be responsible for the SQL Server Storage Engine and in this session he'll explain how SQL Server stores and retrieves your data and what choices you can make to allow SQL Server to perform well. This session will give you the insight you need to make correct design choices!

What's New in the Visual Basic 10 and C# 4
Beth Massi - NET315 -> Material Evaluation Add to my schedule
Microsoft has decided to Co-evolve their premiere .NET languages, Visual Basic and C#. In this session you'll learn about the new capabilities of the next version of both of these languages, including additional productivity features and syntax simplifications. You will also gain insight into language team's strategy and direction for implementing new features.

“Lighting Up” an XP App
Kate Gregory - NET372 -> Material Evaluation Add to my schedule
Best Practises for “Lighting Up” an XP Application on Windows 7

So you have an application that works fine on XP, and you’ve got it working ok on Windows 7. Are you done? Not really – now it’s time to turn it into a real Windows 7 application. Working with a reference application that behaves differently on XP and Windows 7, I’ll show you the user interface (and behind the scenes) changes that let an application take true advantage of what Windows 7 has to offer. This session is more about inspiration and ideas than code. The companion session on the Windows API Code Pack (later the same day) will provide plenty of code samples.


Silverlight 4.0 Track

Application Prototyping with SketchFlow
Kelly Cassidy - SLV234 -> Evaluation Add to my schedule
SketchFlow is an addition to the Expression Blend tool that allows for a rich, interactive prototyping tool. It allows for the "sketch" method of design and workflow development, but also contains a strong feedback mechanism for reviewing the system. This talk will cover the basics, walk through the creation of an application prototype, and play around with the feedback mechanism. It is designed to give an overview of why you might want to prototype an application that is strongly dependant upon a well-defined User Interface and the benefits of considering such design and workflow up front.

Blendability
Barry Gervin - SLV371 -> Material Evaluation Add to my schedule
Microsoft has continued to make investments in both Expression Blend and Visual Studio to facilitate the workflow between the designer and developer roles. This is even more important if you as an indivvidual fulfill both of these roles. However, having version control support in Blend and a design surface in Visual Studio 2010 isn't enough to ensure this back and forth workflow is smooth. In this session we'll examine techniques and patterns to ensure that your projects remain "Blendable" and "Testable" from start to finish. We'll review patterns such as model-view-view-model and attached behaviours to provide not only clean separation of conerns and testability, but also that elusive "Blendability" allowing you to take advantage of Blend's power throughout your project.

Improve User Experience with (NUI)
Tim Huckaby - SLV291 -> Evaluation Add to my schedule
Using Natural User Interface (NUI) Technologies to Improve User Experience

This session will demonstrate how multi-touch enabled applications can be used in multiple vertical industries to improve the communication, education, collaboration, and experience overall across the software continuum. The user experience demonstrations will highlight the use of these Microsoft technologies:

  • Windows Presentation Foundation (WPF) can be used to visualize data. WPF is the next-generation presentation sub-system for Windows. It provides .NET developers and designers with a unified programming model for building rich Windows smart client user experiences that incorporate UI, media, and documents.
  • Windows 7 Touch - Windows 7 offers more choice in how users interact with their PCs, such as through MultiTouch gestures. With WPF support for Windows 7 MultiTouch .NET programmers have a revolutionary new way to build interactive user experiences.
  • Microsoft® Silverlight™ is a cross-browser, cross-platform, and cross-device plug-in for delivering the next generation of media experiences and rich interactive applications for the Web. And with its 3.0 version it is multi-touch capable.
  • Microsoft Surface is a multi-touch product from Microsoft which is developed as a software and hardware combination technology that allows a user, or multiple users, to manipulate digital content by the use of natural motions, hand gestures, or physical objects by the use of natural motions, hand gestures, or physical objects.

Leverage WCF RIA Services with Silverlight
Brian Noyes - SLV367 -> Material Evaluation Add to my schedule
Leverage WCF RIA Services for a Quick N-Tier Silverlight Solution

WCF RIA Services provides a way to quickly construct n-tier solutions for Silverlight client applications, reducing the amount of manual service defintion and hookup and duplication of code that often results in building such a solution manually. This session will walk you through the features of WCF RIA Services, what it does well, what is not so great, and how to get the most out of this framework.

On the Desktop with Silverlight 4
Bruce Johnson - SLV387 -> Material Evaluation Add to my schedule
Silverlight 3 introduced Out-Of-Browser and Offline Support. Silverlight 4 goes way beyond "Out of the Browser" and into the realm of "On to the Desktop" with a littany of desktop application features: Webcam & Microphone support, Copy & Paste to the OS, Drag & Drop from the desktop, Mouse wheel and right click context menu support, Printing, html hosting, Toast Notifcations, and utilizing desktop assemblies without recompilation. Silverlight 4 also includes a trusted application model to escalate permissions to access local documents, execute desktop applications, COM automation and with the support of Group Policy to manage and control which applications can receive this trust. At the end of this session you'll be both inspired by the possibilities of Silverlight 4 and thoroughly confused at the blurred line between WPF and Silverlight.

Visualization Applications with WPF & Silverlight
Tim Huckaby - SLV265 -> Evaluation Add to my schedule
Building Data Visualization Applications with WPF & Silverlight

This session will be heavily demo focused to accentuate how the power of the Windows Presentation Foundation (WPF) and Microsoft Silverlight can be used to visualize data to produce amazing software. WPF is the next-generation presentation sub-system for Windows. Silverlight is a broad reach sub-set of WPF that runs cross platform in the browser. These two XAML based developer technologies provide developers and designers with a unified programming model for building rich Windows client and RIA (Rich Internet Application) user experiences that incorporate UI, media, and documents. WPF & Silverlight use vector based graphics rendering, which results in better graphics and presentation for an application. WPF & Silverlight also has other consistent 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 and Internet applications. These XAML based developer technologies are manifested in 3 major application platforms (Windows Client (WPF), Silverlight & Microsoft Surface) and all will be covered in this session at some level.


Software Architecture Track

A .NET 3.5 Architecture
Erik Renaud - ARC379 -> Material Evaluation Add to my schedule
Have you ever wondered what an architecture based on .NET 3.5SP1 for enterprise development would look like? Have you ever wondered how all those technologies (such as REST, Entity Framework, Composite WPF, SSAS) all fit in? Have you ever wondered where you should be applying patterns such as IOC and the Service Locator? Have you ever wondered about layers and tiers? This talk will use modeling techniques in order to show you all these things, and more. You`ll acquire the skills to position each and every technology, pattern and layer that come with the .NET 3.5SP1 platform; but more importantly, you`ll have the skills to document such an architecture to present it to your team.

Agile Application Architecture
Mario Cardinal - ARC359 -> Material Evaluation Add to my schedule
Add testable interfaces to a layered architecture

This presentation has been conceived to give you a head start in architecting with agile practices. Software architecture is about creating abstractions to tackle complexity and to achieve simplicity. Agility is about systematically coping with changes by confirming correctness at any time and by emphasizing simplicity rather than complexity. The simplest way to achieve simplicity is to divide into layers and to hide each layer behind an interface to isolate dependencies. Hiding complexity using an interface is not widely known like layering but if you combine both practices in the same architectural style you get an effective approach to achieve simplicity. This is the rationale for Agile Application Architecture (AAA). The goal of AAA is to provide abstractions such as interfaces, tests and mockups, which make possible to create a new semantic level to be more precise with regard to the contract of a layer. This precision is important to effectively communicate with programmers and also to adequately validate the implementation. One of the major benefits of AAA it is that since tests are executable, correctness with regard to architecture can be confirmed at any time. Overall, you will acquire fundamental knowledge not only about layered architecture but also about how to design an agile architecture.

Architecting Software as a Service
Michael Stiefel - ARC367 -> 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.

Becoming an Architect
Rob Daigneau - ARC310 -> 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?"

Command and Query Responsibility Segregation
Erik Renaud - ARC387 -> Material Evaluation Add to my schedule
Command and Query Responsibility Segregation, let's kiss it.

What is Command And Query Separation, why would we want to have that kind of architecture ? How do we build such a system, what do we have to think about ? What would it look like ? Is it expensive ? is it scalable ? is it efficient ? Come and hear what nVentive's Erik Renaud has to say on the subject, and how they are building next generation systems upon these principles.

Design strategies for an CRM application
Shan McArthur - NET340 -> Material Evaluation Add to my schedule
Design strategies for an CRM application: designing your application on top of Dynamics CRM

Most software architects and developers are familiar with designing an application on top of SQL Server or SharePoint, but are not familar with using Dynamics CRM as a platform. This session will start off with a high level overview of Dynamics CRM covering the main features from the viewpoint of an application architect. The session will also demonstrate how Dynamics CRM can be used as an underlying business data platform to rapidly build line of business applications and deploy them to your users. This session will also cover Dynamics CRM Online, and Windows Azure and demonstrate strategies to successfully use them together.

How to Partition and Layer a Software Application
Michael Stiefel - ARC321 -> Material Evaluation Add to my schedule
"How do you make your software adaptable to changing technologies? Everyone answers: use layering. But exactly how do you develop software layers, create application interfaces that allow you to change the underlying technology? This is especially crucial as we begin to think about cloud computing and realize that parts of applications may migrate to the cloud, while others stay on desktops and local servers. This session will focus on techniques such as interface based design, proper use of inheritance, inversion of control, factories, single responsibility, facades, and other patterns and techniques to accomplish this. Most of the talk will be spent demonstrating with code how to evolve a tightly coupled application into a properly layered one. "

Introduction to CSLA
Chris Dufour - ARC344 -> Material Evaluation Add to my schedule
"Building rich applications can be a challenge in today’s environment. You have a wide range of UI technologies and patterns to choose from like ASP.NET, MVC, MVP, MVVM, SilverLight, Mobile, WFP, WCF. To complicate matters UI techniques are evolving and you often find yourself supporting many presentation layers. CSLA (Component-Based, Scalable, Logical Architecture) is a fantastic framework for building business objects which tie together the multitude of UI choices with the data provided by any number of access technologies.

The primary focus of CSLA .NET is to help in the creation of a rich object-oriented business layer that expresses the needs of the business domain model. CSLA objects provide rich databinding, validation and authorization making them a logical choice for today's business applications and services. This talk will provide an introduction to CSLA.

LINQ in Layered Applications
K. Scott Allen - ARC355 -> Material Evaluation Add to my schedule
If you are building applications with LINQ there are a number of tradeoffs you need to evaluate from an architectural perspective. In this session we'll talk about deferred execution and the important performance distinction between Enumerable and Queryable data sources. We'll look at the decisions you need to make when deciding on the flexibility, extensibility, performance, and maintainability of your application when using Language Integrated Query.

Separate Your UI Concerns with MVVM & Prism
Brian Noyes - ARC327 -> Material Evaluation Add to my schedule
WPF and Silverlight have a lot of capability for creating compelling UI. But without some patterns to control things, you can easily end up with a mess of unmaintainable code. This session will focus on the Model-View-ViewModel pattern and what it does for you, as well as the UI Composition, Modularity, Commands and Pub-Sub events that Prism (Composite Application Guidance for WPF and Silverlight) offers.

Two-Phase Commit is Evil
Rob Daigneau - ARC343 -> 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.

Visual Studio 2010 is for Architects
Barry Gervin - ARC386 -> Evaluation Add to my schedule
Visual Studio 2010 Ultimate Edition introduces brand new designers and modelling tools for the Architect including tools for not only planning and design software, but also for understanding existing software assets. Using the Layer and UML Diagrams, Architects now have tools to help them plan and design software. But green field development is not always a luxury that we have and architects must review the implementations of their designs. To help understand the architecture of existing code bases, and plan accordingly, the new Architecture Explorer and Graphs allow you to discover and visual the complex inter-relationships between modules of code. Come learn more about these features in this session.


SharePoint 2010

Building app. with Silverlight and SharePoint
Mano Kulasingam - SPT374 -> Material Evaluation Add to my schedule
Building Advanced Rich Internet Applications with Silverlight 4 and SharePoint 2010

Build great rich internet applications using Silverlight and the rich collaboration platform of SharePoint 2010. SharePoint 2010 features new tools that make it easier to build with Silverlight, including a new Silverlight object model and REST services. In this session, you will see how to combine the capabilities of SharePoint and Silverlight together to great user experience. The session will cover a few basic scenarios, and move to more full-feature line-of-business and social applications that leverage the best of these platforms.

Building Business Productivity Solutions
Beth Massi - SPT321 -> Material Evaluation Add to my schedule
Building Business Productivity Solutions with Visual Studio 2010

The Visual Studio and Office teams have made significant investments in improving the developer experience for building and deploying Office and SharePoint applications. In this demo-heavy session, we will walk through an end-to-end business application built on Office and SharePoint and discuss architecture options to consider when building these systems. You'll learn how to use Visual Studio and it’s enhanced set of RAD tools that allows users to consume external line-of-business data within the familiar Office UI. See how new language enhancements will make developers more productive whether they write their code in VB or C#. Finally, you’ll learn how Visual Studio 2010 makes it possible to provide a more seamless end-user deployment experience for Office solutions.

SharePoint 2010: A Developers Primer
Rob Windsor - SPT311 -> 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 Microsoft SharePoint Foundation developer APIs, as well as the types of components and applications in which they can be utilized. Topics covered include Visual Studio tooling for SharePoint, developer object models, creating simple web parts, and working with event handlers.

Social Computing with SharePoint 2010
Andy Nogueira - SPT347 -> Material Evaluation Add to my schedule
In this session we will explore the new Social Computing features that are available in the new SharePoint 2010. We will demonstrate the new capabilities that will allow you to create amazing Enterprise Social Computing (ESC) solutions using SharePoint. We will dive into some code examples and demos to truly explore the new and rich set of APIs that are now available in SharePoint 2010.

Use MS Search Server to build search solutions
James Schwartz - SPT328 -> Material Evaluation Add to my schedule
Leveraging Microsoft Search Server to build custom search solutions

MOSS 2007 Search is conventionally used for indexing and searching for documents and web pages in SharePoint, file shares, and web sites, but it is very rarely ever used for other entities like products, inventory, customers, employees, and other data that can be structured in XML. We will spend the first half of our session providing a technical overview of the Microsoft search stack – Microsoft Search Server Express vs. Microsoft Search Server vs. MOSS 2007 search vs. FAST search which we will only touch on briefly. The second half of the session will dive in to demonstrate end-to-end how you can get the most out of search by indexing and displaying XML content, independent of data source and free using Microsoft Search Server Express 2008. We will also discuss Search as a Service and the general pitfalls to watch out for.

Workflow Development in SharePoint 2010
Ed Musters - SPT345 -> Material Evaluation Add to my schedule
In this session we will cover the A to Z possibilities for workflow development in 2010, with a specific focus on new features and capabilities.  We will start with a workflow in Visio, transition to workflows in SharePoint Designer with the new ability to create site level workflow templates, and finally move over to workflow development in Visual Studio 2010 using its templates and tools.


Pre-Con

Agile Application Architecture By Mario Cardinal
Mario Cardinal - PRE333 -> Evaluation Add to my schedule
This workshop has been conceived to give you a head start in the design of an agile architecture using practices such as interface based programming, test-driven design and continuous integration. Software architecture is about creating abstractions to tackle complexity and to achieve simplicity. The simplest way to achieve simplicity is to divide complexity into layers and to hide each layer behind a visible interface. Hiding complexity using an interface is not widely known like layering but if you combine both practices in the same architectural style you get an effective approach to achieve simplicity. This is the rationale for Agile Application Architecture (AAA). AAA substantially reduces the intrinsic complexity of a layered architecture by adding a testable interface for each layer. The goal of AAA is to provide abstractions such as interfaces, tests and mockups, which make possible to create a new semantic level to be more precise with regard to the contract of a layer. This precision is important to effectively communicate with programmers and also to adequately validate the implementation. One of the major benefits of AAA it is that since tests are executable, correctness with regard to architecture can be confirmed at any time.

Indexing for Performance with Kimberly L. Tripp an
Kimberly L. Tripp - PRE245 -> Evaluation Add to my schedule
Primary presenter: Kimberly L. Tripp, Co-presenter: Paul S. Randal, Pre-conference workshop Indexing is by far the most important aspect to database performance and health. But, do you have the right indexes? Do you have too few, or too many? And, are the indexes the RIGHT indexes? In this workshop we'll cover what makes an index useful and how to create the RIGHT indexes for a variety of different problem scenarios. Primary topics covered: index internals, indexing strategies and lots of insight into whether or not your strategies are working! If you want better performance, better cache utilization, easier maintenance - you need the RIGHT indexes. To create a more effective indexing strategy, this is the place to be—even if you cannot change your schema!

Silverlight 4.0 with Bruce Johnson and Barry Gervi
Barry Gervin - PRE345 -> Material Evaluation Add to my schedule
Building Rich Internet Applications that combine data and media to deliver a great user experience is what Silverlight is all about. And while individual sessions can show you the features, what you can't get in an hour is the full, end-to-end development workflow. In this full-day pre-con, we'll walkthrough the building of a "Personal Conference Organizer" application that helps us discover, select and navigate our way around the available sessions in this conference. Along the way, we'll pay special attention to the features introduced in Silverlight 3 and Silverlight 4.


Post-Con

Agile Development with IoC and ORM by James Kovacs
James Kovacs - POS355 -> 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.

Developers Can't Ignore SQL Server Database Mainte
Kimberly L. Tripp - POS221 -> Evaluation Add to my schedule
Primary presenter: Paul S. Randal, Co-presenter: Kimberly L. Tripp, Post-conference workshop There's a common misconception that database maintenance isn't critical, or is something best left to the DBA (if you have one). It's not true! If your application includes a SQL Server database then neglecting database maintenance can lead to poor performance, data loss, and application down-time. This session will give you a good understanding of the top areas of database maintenance to watch out for and some simple guidelines you can follow to ensure your databases don't cause avoidable problems for you or your customers.
Note: Space is limited

Sharepoint 2010 with Rob Windsor
Rob Windsor - POS365 -> Evaluation Add to my schedule
This session is a day-long overview of development on the SharePoint 2010 platform. It is designed for those new to SharePoint, but will prove interesting to seasoned SharePoint developers looking to find out about the new features in 2010. We will begin with a look at foundational topics like Feature and Solutions Packages and then see how we can use the developer tooling in Visual Studio 2010 to quickly and effectively build customizations contained in these artifacts. Over the course of the day we will explore the SharePoint developer APIs, how to build custom web parts, working with SharePoint lists and libraries, and options to access data stored in SharePoint.


Sessions Archive

DevTeach Vancouver 2009

DevTeach Montreal 2008

DevTeach Toronto 2008

DevTeach Vancouver 2007

DevTeach Montreal 2007

DevTeach Montreal 2006

DevTeach Montreal 2005

DevTeach Montreal 2004

DevTeach Montreal 2003






Copyright © , DevTeach Inc., All Rights Reserved, Hosted by DevTeach inc. - Privacy Policy
.NET Conference 112 de Roquebrune, Gatineau, Quebec, J8T 7Y5 .NET Training
Telephone: Fax: Email: