Community Events

Français · Montreal, January 07, 2010 00:30 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 -> 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 -> 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 -> 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 -> 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 -> 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 -> 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.

Developing big scaly websites for Windows Azure
Chris Hay - NET362 -> Evaluation Add to my schedule
Now that Windows Azure is here, if your website can't scale, you only have yourself or your manager, or your bank manager, or Ray Ozzie to blame. In this session we'll focus on what it takes to make a scalable Web Tier in Windows Azure. We'll look at Web Servers under load, Scaling Up, Scaling Out, Load Balancing, Sessions, Caching, CDN's

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 -> 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 -> 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.

Using Dynamic in C# to do Amazing Things
Aaron Erickson - NET453 -> 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 -> 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 -> 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 -> 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.

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.

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 -> 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.

Optimizing Procedural Code
Kimberly L. Tripp - SQL345 -> 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 -> 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.

Tips and Tricks for Proper SQL Server Table Design
Paul Randal - SQL355 -> 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 -> 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 -> Evaluation Add to my schedule
Best Practises for “Lighting Up” an XP Application on Windows 7

More details soon...


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 -> 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 -> 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 ses 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.

On the Desktop with Silverlight 4
Bruce Johnson - SLV387 -> 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 -> 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.

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

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 -> 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 -> 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 -> 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.

Test-Driven Architecture
Mario Cardinal - ARC359 -> Evaluation Add to my schedule
Add a visible and testable interface to your layers

This presentation has been designed to give you a head start in modularity practice with a layered architecture. As has been said by Albert Einstein, "Everything should be made as simple as possible, but not simpler." Test-Driven Architecture (TDA) substantially reduces the intrinsic complexity of a layered architecture by adding explicit contracts between the layers. Using practical examples, this presentation demonstrates how to apply “test-driven” design techniques to define the visible interface of a layer. The goal of TDA is to provide an abstraction, the architecture tests, 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 to the programmers the detail architecture and also to adequately validate the implementation. One of the major benefits of TDA it is that since tests are executable, correctness with regard to architecture can be confirmed at any time. Overall, you will acquire fundamental knowledge about how to add a visible and testable interface to your layers.

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


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: