Community Events

Français · Montreal, March 21, 2010 11:51 ET
 
   

Sessions

DevTeach 2005 tracks Archive


Smart Client Development

Data Caching Strategies for .NET Distributed App.
Beth Massi - NET450
The performance and scalability of a distributed application can be greatly increased by implementing data caching strategies. ASP.NET provides a nice caching framework for web clients, however, smart clients can also take advantage of complex caching strategies because they typically have access to local storage and memory. In this session we will explore:

-Why and when to use caching
-Common caching strategies
-Caching sets of data on the server
-Local storage of DataSets and objects(serialization/deserialization)
-Implementing caching strategies in Winforms clients
-Caching “gotchas”
-Caching enhancements in VS 2005

Deploying Smart Client Apps Using ClickOnce
Brian Noyes - NET237
Imagine all the benefits of the Web application deployment model brought to the Windows smart client applications. ClickOnce, part of version 2.0 of the.NET Framework, allows the deployment of Windows-based rich client apps by placing the application files on a Web or file server accessible to the client and providing the user with a link. This session covers Visual Studio 2005 deployment capabilities for online and offline application support, rolling back to previous versions of an application, listing an application in the Start Menu and control panel, .NET Framework redistribution, and zone-based debugging. Learn how to configure security to allow smart client applications to safely download and run.

Getting Ready for ADO.NET 2.0
Kevin McNeish - NET387
This session helps you get ready for ADO.NET 2.0 by introducing and explaining many new features including asynchronous data fetching, data paging, bulk import, monitoring of connection-specific statistics, and connection pooling enhancements. You will also learn about new SQL Server 2005-specific capabilities in ADO.NET 2.0 such as multiple-active result sets, password changing, promotable transactions, client-failover, and support for user-defined types and other new data types. Practical examples are provided demonstrating how to get the most out of these new features.

Secure Smart Client ClickOnce Deployments (2.0)
Brian Noyes - NET350
Deploying distributed applications with ClickOnce solves many maintenance and supportability issues with smart client applications due to its easy to use model. But along with that flexibility come concerns about the security of applications deployed with ClickOnce. This technology supports a rich model for deploying applications in a trustworthy fashion that will prevent any harm to the client machine during deployment, as well as a rich runtime security infrastructure that ensures that the application is not allowed to perform any operations or access any resources that it should not. This talk will cover the security facilities of ClickOnce, discussing and demonstrating how to define and configure the security requirements for a ClickOnce deployed smart client application. It will start with a quick introduction to ClickOnce and how it works, and then proceeds directly into the security aspects of the technology. The session will demonstrate how to configure trusted publishers that can determine what permissions a ClickOnce application will be granted without user prompting, how to allow user prompting for Internet scenarios, as well as how to use traditional .NET Code Access Security code groups to go beyond the ClickOnce facilities for special situations.

Tackle Complex Data Binding in Windows Forms 2.0
Brian Noyes - NET351
Windows Forms 2.0 introduces a host of new capabilities for managing data binding scenarios. The BindingSources component allows you to easily bind to almost any kind of data source, and the Data Sources window in Visual Studio 2005 makes it easy to generate the code to hook up BindingSources to controls. This session will demonstrate the use of BindingSources and the Data Sources window to handle a variety of complex data binding scenarios including Master-Details, data bound custom controls, and forms with multiple sets of connected controls.


Security with .NET

A tour of WSE 3.0
Christoph Schittko - NET274
The Web Services Enhancements (WSE) are Microsoft’s product to track the latest Web services as they evolve. This is somewhat of a double edged sword for Microsoft. On one hand, WSE gives customers a fully supported product to build applications against the latest standards. On the other hand, changes in the underlying standards can break compatibility between WSE releases.

This session introduces the latest release from the WSE team and examines the newly added features, WSE 3.0, which will be released alongside with Whidbey. The session also compares how WSE 3.0 fits and interoperates with WSE 2.0 and the upcoming Indigo framework.

Security Basics for Web Service Enhancements 2
Julia Lerman - NET155
Before digging too deeply into Web Services Security, it is critical to get a good handle on the key tools in security. Not only will you be able to better understand what you are working with in WSE, but when it comes time to problem solve, you will be in a much better position. Come to this session to learn about certificates, encryption, signing and other important security elements that are the basis of everything that is done in Web Services Security. This session will give you the knowledge you need to comprehend the many articles and presentations on WSE2.

Security Through Least Privilege
Don Kiely - NET246
Least Privilege is one of the first principles of developing secure applications. But what does it mean? How do you do it? Why is it so critical? This session will explore how to develop apps that give the absolute minimum permissions to every user and login and still meet application and user requirement, as well as explore—gasp!—why developing without admin privileges on your development machine leads to much stronger and secure apps. Code access security is a great feature of the Common Language Runtime, but requires that you live the unprivileged lifestyle yourself. Least privilege isn't easy to use or implement, but in this day and age it is the only way you and your users have reasonable confidence in the security of an application. Come learn how to life the partially trusted life.

Security, The New Reality, Part 1
Patrick Hynds - NET234
Duet with Duane Laflotte
Patrick Hynds (Good Guy/Developer) and Duane Laflotte (Bad Guy/Hacker) The .NET platform has raised the bar on built in security mechanisms which makes life easier for developers to incorporate sound security design in their applications. But the challenge of security is an infinite surface, and there are trade-offs in every decision for what will be protected and what will not. We need to do this right especially since according to Dshield.org the average Internet connected system gets attacked every 21 minutes. In this session we will explore the best way to approach decisions about securing your applications, highlighting the tools and techniques used by both the hackers and the hacked. In Part 1 of this unique setting we will watch an application evolve from easily hackable (worst practices) to average security (still too easy to hack as you will see). In Part 2 we will see the application evolve further to one which is secured within a reasonable cost in terms of effort and dollars. Consider this the Spy vs. Spy, Hacker Edition.

Security, The New Reality, Part 2
Duane Laflotte - NET333
Duet with Patrick Hynds
Patrick Hynds (Good Guy/Developer) and Duane Laflotte (Bad Guy/Hacker) The .NET platform has raised the bar on built in security mechanisms which makes life easier for developers to incorporate sound security design in their applications. But the challenge of security is an infinite surface, and there are trade-offs in every decision for what will be protected and what will not. We need to do this right especially since according to Dshield.org the average Internet connected system gets attacked every 21 minutes. In this session we will explore the best way to approach decisions about securing your applications, highlighting the tools and techniques used by both the hackers and the hacked. In Part 1 you watched as an application evolved from easily hackable (worst practices) to average security (still too easy to hack as you will see). In this second part we will see the application evolve further to one which is secured within a reasonable cost in terms of effort and dollars. Consider this the Spy vs. Spy, Hacker Edition.

Store .NET App Data Securely
Don Kiely - NET247
In the age of Code Access Security and partially trusted applications, where can you store application data? All applications need to save configuration and runtime data somewhere, but common solutions like the registry, databases, and disk files are fraught with security issues. This session explores various options for storage where you may not need special permissions. For example, .NET's isolated storage provides a secure, protected place to store data without the security issues of writing to a disk outside of your Web application and subdirectories. During this session we'll explore how to put these storage options to use in .NET applications while avoiding potential sources of security holes.

Visual Studio 2005's New Security Tools
Don Kiely - NET245
Visual Studio 2005 includes new security tools that will provide static security defect detection, prevention, and mitigation features for both unmanaged and managed code. More than ever before, your everyday development environment will have the tools you need to build secure applications and, more importantly, verify that they are secure. There are still no guarantees that your apps will be bullet-proof, but at least you can rest easy that they are reasonably free of the most widely exploited security holes. Come learn about these tools and start helping your users rest better at night.


Web Development with .NET

ASP.NET Data Caching Magic
Carl Franklins - NET479
In this talk I show you how to do the impossible, automatically update a dataset in the cache when the data in the database changes, without requiring a request from the user. That's right, it happens in the background. I'll take you through the Rube Goldberg of algorithms to show you exactly how it works, and take you on a tour of a local newspaper's website in the real world that uses this technique.

ASP.NET Tips and Tricks
Cathi Gero - NET236
This session demonstrates a variety of advanced techniques that you can leverage to build more powerful and scalable ASP.NET Web applications and XML Web services. We'll cover how to use scrollable sections in your pages to allow for more information to be presented to the user. Learn new ways to work with the DataGrid to provide more rubust features like custom paging and working with rows. Learn how to provide emailing capabilities inside of your Webforms, including working with attachments. We will look how you can use the System.Drawing classes to provide rich image capabilities like using thumbnails and manupulating graphic objects. Learn how to work with the application object to allow storage of global data to be used throughout your application. Finally, we will look at how to use screen scraping inside of your applications when you need to gather information from other sites. If you're creating Webform applications using .NET, you'll certainly find some new tips and tricks in this session!

Chut! Secrets des Maîtres Développeurs dévoilés
Eric Coté - NET276
Duet with Mario Cardinal The same team that brings you the "Blah Blah Dot Net" PodCast is teaming up once again to give a lively session which will blow everyone away.

Everyday, we witness the magic that Code Gurus produce. But how do they do it? In this talk, we pull out the curtain and look at how they pull it off. We'll look at the strange techniques that they use: Architecture, Refactoring, Naming conventions, Unit testing, Automatic builds... We'd like to divulge more, but shhhh! That would be telling!

Extending ASP.NET with Custom Handlers and Modules
Brian Noyes - NET352
Extending ASP.NET with Custom Handlers and Modules (1.1)

ASP.NET provides a great deal of capability "out of the box" that addresses many application requirements. However, occasionally you need to do more advanced things like provide custom security mechanisms, process requests in a way that do not correspond to rendering pages, or intercept and filter requests across your application. ASP.NET provides a rich and extensible request processing architecture that allows you to plug in custom functionality at several levels. This session will demonstrate how to create custom HTTP Handlers and Modules to allow you to perform any kind of custom request processing that you need in your application.

Sites Web Multilingues avec ASP.NET 2.0
Eric Coté - NET277
With the original ASP.NET, it took a lot of sweat to create great multi-language web sites. Now with ASP.NET 2.0, it will be possible to create an international web sites with a lot less work. In this session, we review how localization was done with ASP.NET 1.1, and then we delve into how you should localize with Visual Studio 2005. We'll take a long look at the new resource management available in ASP.NET 2.0

Survol des nouveautés de ASP.NET 2.0
Dominic Sevigny - NET120
ASP.NET 2.0 for dummy’s
More details to come.

Trucs et astuces avec ASP.NET 2.0
Dominic Sevigny - NET220
ASP.NET 2.0 Tips & Tricks

What's new in ASP.NET 2.0 Framework
Rick Strahl - NET123
This session takes a look at new and updated features in the core ASP.NET framework. We'll look at how the new Page model works, how to work with the new compilation and deployment modes, how you Master Pages fit with page design and fit into the Page framework. We'll also look at some core features like the new features in the state stores, improved support for Page AsyncHandlers, and some of the new administration and configuration features.


Architecture with .NET

Design Patterns in .NET
Claudio Lassala - NET261
Design Patterns are often used every day by every developer in one way or another. A basic understanding of patterns and how to implement them is very useful for all .NET developer, and this session tries to clarify design patterns in a way that everybody can understand and start thinking about patterns in a more natural way.

Designing .NET App. for Multiple UI Part I
Beth Massi - NET451
Duet with Nickolas Landry
How can you design a scalable distributed application to easily work with multiple client user interfaces, be they web-based or smart clients? The obvious answer is to use a Service-Oriented Architecture (SOA); however, other choices may exist depending on the requirements of the system. If you are developing a system where besides scalability the main goal is supporting multiple UI’s, there are techniques and patterns you can use to speed-up development and create a better end-user experience. If you have control over user interface development you can use that trust in your favor and create specific client front-ends based on user needs and better performing systems in less time. Things we’ll cover include:

-Architecture considerations of distributed applications
-Deployment scenarios
-Designing scalable, stateless components
-Choosing a common package for data
-Creating façade layers for multiple remote access strategies
-Windows forms client development; databinding, validation; code generation, dynamic UIs

Designing .NET App. for Multiple UI Part II
Nickolas Landry - NET452
Duet with Beth Massi
How can you design a scalable distributed application to easily work with multiple client user interfaces, be they web-based or smart clients? The obvious answer is to use a Service-Oriented Architecture (SOA); however, other choices may exist depending on the requirements of the system. If you are developing a system where besides scalability the main goal is supporting multiple UI’s, there are techniques and patterns you can use to speed-up development and create a better end-user experience. If you have control over user interface development you can use that trust in your favor and create specific client front-ends based on user needs and better performing systems in less time. Things we’ll cover include:

-Mobile Client Development
-Mixing .NET 1.1 and 2.0 assemblies in the same distributed system

Distributed .NET
Ted Neward - NET224
There are, at last count, at least five different ways to build distributed systems in .NET: HTTP-based communication using ASP.NET, .NET Remoting, COM+ hosted components, messaging (MSMQ, among others), and Web Services (not to mention Indigo in the coming years). In this talk, we'll briefly discuss and show some brief example code exploring each in turn. Then, introductions done, we'll get down to the ugly business of figuring out when each is necessary, and why.

Indigo Internals Part I
Steve Swartz - NET332
The Indigo feature set is implemented almost exclusively on its own extensibility points. This talk introduces the public internals of Indigo. It has two goals: you should understand how Indigo works under the covers, and you should understand how you might extend it yourself.

Indigo Internals Part II
Steve Swartz - NET432
The Indigo feature set is implemented almost exclusively on its own extensibility points. This talk introduces the public internals of Indigo. It has two goals: you should understand how Indigo works under the covers, and you should understand how you might extend it yourself.

Introduction a Visual Studio Team System 2005
Etienne Tremblay - NET195
Sessions details in progress

Introduction to Indigo
Ted Neward - NET223
Indigo is Microsoft's new enterprise communications and transactions stack, and represents the "next generation" beyond COM+, ASMX, Enterprise Services, .NET Remoting, and MSMQ. Come hear the scope and breadth involved in Indigo, the basic architectural model, and why Indigo looks to make .NET a solid bet for enterprise systems in the coming decades.

MSBuild: Release Engineering for .NET 2.0/Longhorn
Nickolas Landry - NET242
It’s Friday morning, 11:00am. You have completed the change requests for your system and QA has approved your new version. Now what? How do you create a build for this thing? Carl “the Build Guy” is away on vacation, sun tanning 2 hours away from the nearest phone or data port. Fortunately for you, Carl used MSBuild… MSBuild is the brand new extensible, XML-based build engine brought to us by the .NET Framework 2.0 and future versions of .NET for “Longhorn”. While it can be leverage fully from within Visual Studio 2005, MSBuild is available to all as it is part of the Framework’s architecture. You do not even need Visual Studio to be installed to create a build and the whole project is XML-based. This session explores how MSBuild extends the concept of simply building an application to a multi-stage process that starts at the Source-Code Control level, reaching all the way to building, testing, obfuscating the new build and more. We’ll discuss how you can also customize the build process through a comprehensive task extensibility model, such as adding logging tasks. This is a no-nonsense hands-on session you cannot afford to miss where you get to see MSBuild in action through extensive demonstrations.

OOPs - Now I’ve got it!
Claudio Lassala - NET260
Understanding the basics of Object Oriented Programming (OOP) is crucial. But there is more that a developer must know. In this session we see some of the intermediate and advanced concepts, as well as we scratch the surfaces of UML and Design Patterns. This session will teach these concepts using easy-to-understand samples, rather than using the standard, abstract, and "super-human" examples most OOP explanations usually favor.

Secure, Reliable, Transacted Programming in Indigo
Steve Swartz - NET231
Indigo is built on a set of standard protocols that allow you to build interoperable web services that are secure, reliable, and transacted. This talk explores all those features by focusing on common scenarios and examining the sort of code and configuration you'd use to implement them with Indigo.

Software Architecture interest group GUVSM
Joel Semeniuk - NET333
Subject:To be annonced
Speaker: Joel Semeniuk, Microsoft Regional Director, Winnipeg

After the break Speakers panel with:

  • Nickolas Landry, Microsoft MVP on the .NET Compact Framework
  • Beth Massi, Software Architecture MVP
  • Joel Semeniuk, Software Architecture MVP, Microsoft Regional Director Winnipeg
  • Barry Gervin, Software Architecture MVP, Microsoft Regional Director Toronto
  • Mario Cardinal, Software Architecture MVP
  • Carol Roy, spécialiste en architecture .NET pour le secteur public chez Microsoft Canada

Star Wars Episode3:Revanche des architectes zhéros
Mario Cardinal - NET167
A long time ago, in a galaxy far, far away... The galactic republic confronts a lot challenges: out-of-control software projects, code legacy maintenance, everchanging requirements and shortened ship-times. This will lead to an ultimate face-off that pits the forces of the jedi "architects", mentors that defend and share the best coding practices, against the "zheroes", jedi masters that have been lured by the dark side and absolute control over code. Where do you stand? Mastering programming languages is only the first step to become an "architect". It takes devotion, patience and discipline to master Objects, Patterns and Frameworks. It is all too easy to be seduced by the dark side... And to let our projects be self-consumed.

This tongue-in-cheek seminar is ideal for the Jedi novice. The seminar will be led by master Obi-Wan Kenobi (Mario Cardinal) under the helpful guidance of Master Yoda (Eric Côté). May the GoF be with you.

Static Analysis with VS 2005 and FxCop
Claudio Lassala - NET262
You write code and compile it. The compiler doesn’t complain, so you’re all set, right? Well, not really. Maybe the code you wrote isn’t optimized for performance, or maybe it has security breaches, or maybe it doesn’t follow best practices (either the ones accepted in the software development world or the ones required by your company). Long story short, code compiled without compiler errors isn’t always high-quality code. We address that by using static analysis, and this session shows how to use VS 2005 and FxCop to do that.

The Fallacies of Enterprise Development
Ted Neward - NET227
Every enterprise developer, at some point in their career, has fallen into the trap of these 10 enterprise software development assumptions. Come hear what they are, why they all lead to big trouble and painful learning experiences in the long run, and how to avoid them using the tools and technologies of your favorite platform.

The Indigo Programming Model in Depth
Steve Swartz - NET230
Introduction to Indigo gave you a first look at the main ideas behind programming and configuring Indigo services. This talk takes a deeper look at the programming model in the context of rich samples: you'll leave with a pretty good idea of the breadth of the core Indigo feature set.

The New Class and Distributed System Designers
Nickolas Landry - NET388
You may have a basic understanding of .NET's event model, but how can you best architect your applications to take advantage of .NET events? This session spends a few minutes on the basics, then provides real-world examples showing how you can design your applications to take advantage of the .NET event model for things such as:

-Custom data binding in Windows Forms and Web Forms
-Establishing relationships between business components
-Creating world-class, end-user-configurable security
-Localizing the user interface dynamically at run time

Visual Studio Team Architect 2005
Etienne Tremblay - NET295
Sessions details in progress

Web Services Contract First Development
Christoph Schittko - NET273
Development practices of successful distributed system projects ask for immutable interfaces and loose coupling of distributed entities. Web services are no exception in this area. Unfortunately, the ease of turning an ordinary class into a Web service by slapping a [WebMethod] attribute onto a method definition makes it all to easy to forget such practices.

With the accelerating proliferation of Web service technology and the increasing emphasis on service oriented principles, designing a service interface becomes increasingly important. Contract first-style development emphasizes the importance of the interface because it focuses on the development of service interface first. The service interfaces are developed independently of the implementation using only WSDL and XML Schema.

This session examines the benefits of the contract-first approach and demonstrates the available tools from Microsoft , 3rd party vendors and community projects to support the contract-first development style on the Microsoft platform.


Database Development with .NET

Building Reporting with .NET, SQL & Crystal Report
Kevin Goff - SQL277
Dating back to the late 1980’s, one of my specialties has been building reports and reporting modules for a variety of industries. In this session, I’ll present two different reporting requirements in a distributed web environment, and will demonstrate how to construct both reports from beginning to end – defining the data requirements (input parameters and output result sets), constructing the typed datasets, building stored procedures to return the results, creating the report template, and generating the report to different output destinations. Although the examples will be fictitious, they’ll definitely be real-world, and will cover many requirements found in reporting . I’ll use many of the techniques in my CoDe Magazine Baker’s Dozen articles that cover Crystal Reports and T-SQL. The first example is a configurable P & L report for a construction company. The second example, also for a construction company, is a report/graph with monthly profits and costs on a single page. The session will present some reusable tools for report generation. The first example is a vertical and configurable P & L report. The second example is a report/graph with monthly data on a single page.

Custom DataTypes and Aggregates using VS NET 2005
Rod Paddock - SQL369
SQL Server 2005 now has the ability to create custom data types and aggregates using CLR languages like VB.NET and C#. This session will demonstrate how to create, install and use these custom data types in your SQL Server 2005 applications. Discussion of debugging, performance and maintainability will be discussed.

Nouveau type XML de SQL Server 2005
Guy Barrette - SQL226
A brand new XML type is now available in SQL Server. See how it’s possible to directly store XML data right into an XML column. You’ll also see how to combine XQuery right into your T-SQL queries.

Using the XML Data Type
Don Kiely - SQL260
With XML as a native data type in SQL Server 2005, you are now faced with two query engines and syntaxes, good old SQL and the new kid, XQuery. It can be daunting to create queries that mix the two engines and it can be hazardous to your performance. This session will explore the XML data type and XML-specific T-SQL functions you can use with them, how to mix and match the syntaxes effectively, and how to build common queries that extract and modify data at a minimum of two levels: relational data and embedded XML.


Developing with .NET and Tools

.NET Windows Forms Tips and Tricks
Cathi Gero - NET235
This session demonstrates a variety of advanced techniques that you can leverage to build more powerful and robust Windows Forms applications. We'll cover how to take advantage of the user’s system tray to run your application. Then learn how to have your form act like Windows Messenger to provide flashing capabilities. We will also explore how to provide the ability to print a form. Learn how to use extended providers to provide extra functionality for your controls. We will also explore ways to improve the look of your application by adding XP theming and non-rectangular windows as well as how to fade a form when closing. We will look how you can use the System.Drawing classes to provide rich image capabilities like image mapping and image transitioning. Next, learn techniques to improve the performance of your application by loading data on-demand. Finally, we will talk about how to work with DataGrids to auto expand to the largest item in a column as well as how to select all columns in a row. If you're creating Windows applications using .NET, you'll certainly find some new tips and tricks in this session!

ADO.NET Black Belt DataSets
Barry Gervin - NET327
In this session, we'll walkthrough some advanced tips and tricks for everybody's favorite class to hate: The DataSet. We'll examine some of the deep rich features, and look at some internals to understand how this complex feature rich class can also be highly performant if used correctly. We'll look at best practices for using and extending these classes within our WinForms, WebForms and Service applications.

Advanced COM Interop with C#
Sam Gentile - NET256
Many C# developers are finding that they need to interoperate with existing legacy COM components from their C# applications. There are profound differences between the COM and the CLR model and thus COM Interop out of the box doesn’t always do what the C# developer expects. We’ll review Runtime Callable Wrappers (RCWs) and COM Callable Wrappers (CCWs) and then quickly look at code-focused ways of improving your Interop experience

Customized Debuggin in Visual Studio 2005
Julia Lerman - NET156
New features in .NET 2.0 and Visual Studio 2005 allow you to take more control over how information is displayed about classes while you are debugging. Debugger Visualizers are custom user interfaces that can be written to display information about .NET classes or your own custom classes. The new debugger attributes can be applied to your classes to define the formatting of debug info displayed in the watch windows. This session will walk through how to write and deploy custom visualizers as well as how to leverage the new debugger attributes found in the System.Diagnostics namespace.

De-mystifying Regular Expressions in .NET
Jim Duffy - NET241
Regular expressions in .NET, also known as "regex", is an extremely powerful, though quite cryptic tool used for pattern matching and string substitution. In this session, attendees will be introduced to regular expressions, what they are, how they work, and plenty of samples examining why you will want to take advantage of them.

Developing User Interfaces with Avalon
Markus Egger - NET189
The user interface is of tremendous importance as it is the only part of any given application that is visible to the user. Unfortunately, techniques and guidelines for efficient user interfaces remain a subject of mystery for most developers. This session explores user interface design on multiple levels. It discusses user interface design philosophy as well as specific techniques available in Visual Studio and enhanced possibilities in Visual Studio 2005 ("Whidbey"). The session presents many examples based on real-life applications.

Déploiements d'app. WinForms avec ClickOnce
Eric Moreau - NET188
Deploying Windows Forms, or Smart Clients, applications on a large quantity of workstations has always caused headaches. In this presentation, you’ll see how to deploy WinForms applications using the ClickOnce technology included in Visual Studio 2005. Using ClickOnce, you’ll be able to easily deploy your apps using a Web server. You’ll also take a look at how to prepare your applications to ClickOnce and how to set execution permissions.

Enhancing the Design Time Experience
Rod Paddock - NET370
One little explored facet of the Visual Studio Environment is its programmability. You can extend the VS.NET environment in numerous ways. This session will explore how you can make yourself more productive using these programmability tools. You will learn how to add new functionality to .NET Framework and 3rd Party controls using Extender Classes. You will learn how to add your own custom property sheets that look and act exactly like the ones in VS.NET. You will also learn how to enhance the design time experience of your custom controls/classes using Type Editors.

Garbage Collection in .NET
Ed Musters - NET311
Get on your rubber boots and join Ed on a tour of .NET Garbage! - Collection, that is. You may be used to the fact that C++ destructors execute deterministically, run in the order they are called, and can be invoked explicitly. Well, aren't you pleased to find out that precisely the opposite is true in C#! Take control of your waste management by learning about .NET implicit resource management through Finalization and explicit resource management through the implementation of the IDisposable interface. A Temporary Resource Usage Design Pattern will be provided to wrap control of resources you may need to manage (File handles, legacy application interfaces, etc.). Lastly, we'll look at optimizing the garbage collection process with some advanced techniques such as Weak References and explicitly invoking the .NET garbage collection routines. We will examine Garbage Collection in BOTH Visual Studio 2003 and Visual Studio 2005.

Generating .NET Code using the CodeDOM
Dan Jurden - NET325
In today’s business environment, productivity is the key. To be competitive you must be more productive. One way to be more productive in the .NET world is to try to find ways to cut development time. One of the most time consuming tasks is the repetitive kinds of tasks. For example, you might have 100 tables in your database and you need to create business objects for each one. Creating these business objects is not hard work but it is repetitive and time consuming. You have a pattern to follow; create the class, override some methods, create some properties to expose the data columns, etc. The CodeDOM allows you to create a program that can generate this type of code for you, thus making you more productive.

Hardcore .NET
Sam Gentile - NET355
Want to take your .NET knowledge much deeper? Want to more effectively write .NET Framework code that makes maximum utilization of the CLR? In this session, we will dive deep into the CLR in areas like Value vs. Reference Types, Garbage Collection, and more but in a way that focuses on how you can write your code more effectively. Examples of code developed will include avoiding boxing penalties, Whidbey Generics, Implementing IDisposable and Finalizers and more. This is an expert level session designed to take your .NET experience deeper and to become more effective.

Integrating Electronic Payment into Web App.
Rick Strahl - NET280
Find out what it takes to add payment processing to your Web applications. Figuring out which processor to use and what mechanism to choose and how to get it to work in your application is not a straightforward process and this session will guide you through the different options and approaches so you can make informed choices in choosing a provider and implementing payment processing quickly in your Web applications. There are a number of players involved from Gateway Services, to Merchant Providers to the actual bank. This session gives an overview of the typical architecture, an overview of several different payment providers including Authorize.NET, Verisign and LinkPoint as well as payment processing services like PayPal. We'll then see how the various different gateways work and can be integrated into Web applications using an ASP.NET sample application.

Intro to VB.NET 2.0
Carl Franklins - NET278
More details soon..

Introduction to Microsoft Enterprise Library
Mario Cardinal - NET168
Enterprise Library, to be released to the general public in early 2005, is the next generation of the Microsoft’s Application Blocks. Application Blocks are Microsoft's implementation of reusable code (and documentation) that provide proven solutions for commonly recurring problems that you often waste time solving over and over again in enterprise programming. This presentation provides a short introduction to the Microsoft Enterprise Library and shows what each block might be good for. The idea is to present the types of problems Enterprise Library try to solve and where to apply it in your own solutions.

Introduction to WinForms
Jim Duffy - NET157
Learn how to create WinForm desktop applications today with Visual Studio 2003. In this session you'll see how to build forms, work with form classes and typically used WinForm controls, create menus, implement code event handlers, access data with ADO.NET objects, use data bind controls, work with the Application settings, and create MDI forms. You'll take away a solid understanding of what WinForm applications are in .NET, and how to create one.

Introduction à Information Bridge Framework
Carol Roy - NET152
Microsoft Office Information Bridge Framework (IBF) is a technology which allows developers to create and deploy custom solutions that integrate with an organization’s existing IT infrastructure. It reduces development costs and increases flexibility, manageability, security, and extensibility of Microsoft Office-based information integration solutions.

This bridge is composed by a set of components, software tools and information allowing the developer to create solutions that connect Microsoft Office System programs to line-of-business systems through web services or .NET classes. With IBF, users can access their line-of-business applications data from Microsoft Office Word 2003, Microsoft Office Excel 2003, Microsoft Office Infopath 2003 and Microsoft Office Outlook.

Introduction à la sécurité de votre code avec .NET
Rock Legendre - NET251
This session is about Code Base security. The session is in french. See French description for more details

Programming Microsoft Office Solutions from .NET
Bernard Wong - NET199
The subject of developing solutions with Microsoft Office has recently become the subject of much speculation and even uncertainty, for some. While Visual Basic for Applications (VBA) will continue to be included in future versions of Office, it is neither getting younger nor better. In this session, we’re going to look at the programmability options that are available currently for Office solutions. We’ll briefly demonstrate Office automation from Visual Studio via COM Interoperability and the various Office Primary Interop Assemblies (PIAs). We’ll then create some simple Office solutions utilizing the Visual Studio Tools for the Microsoft Office System, Version 2003 (VSTO) and continue with an in-depth look at the inner mechanisms of how these function specifically to address the security and maintainability concerns with the VBA programming model. Lastly, we will conclude our look at Office programmability with an introduction to some of the new capabilities that you can expect later this year in the next version of VSTO.

Programming Office Solutions with VSTO
Bernard Wong - NET298
Having surveyed the most common methods for programming Microsoft Office solutions in the previous session, we’ll now continue with a look at the new features that will be forthcoming in the Visual Studio Tools for the Microsoft Office System (VSTO), Version 2005. We’ll demonstrate how the capabilities of this new version will deliver upon its primary focus of developer productivity integrating together the two worlds of Office and Visual Studio.

Unit Testing in VS 2005 and VS 2003
Dan Jurden - NET226
Today’s applications are much more complex that a few years ago. It is becoming more and more imperative that applications be delivered on time and “bug free”. To do this, developers must become more productive and write more reliable code. One way to do this is to use the unit testing frameworks that are available to you. In VS 2005, unit testing is integrated into the development environment. In VS 2003, there is a testing framework available called NUnit. This session will cover unit testing in both environments.

VS 2005 Team pour les testeurs de logiciels
Carol Roy - NET150
Microsoft, with the next release of its development environment, Visual Studio 2005, will ship an environment that will cover all the software life cycle. This environment, Visual Studio Team System, will bring to the entire development team (architects, developers, testers, project manager, etc.) a set of tools that will largely facilitate the design, the development and the implementation of Service Oriented Architecture.

In this session, Mister Carol Roy, .NET Architect Specialist at Microsoft, will present the set of features dedicated to developers and testers in the testing phase of the software life cycle.

What new in C++ Visual Studio 2005
Kate Gregory - NET340
The enhancements to Visual C++ 2005 enable it to stand toe-to-toe with any tool in terms of support for the .NET Framework, elegance, and productivity. In fact, in many ways it can do things no other tool can. Learn how the CLR brings new features such as garbage collection, generics, reflection, and verifiability to C++ ... and how C++ brings deterministic cleanup, templates, and meta programming to the CLR! Learn how to easily migrate existing native code - including MFC applications - to run under the CLR. Whether you build end-to-end applications or components for enhancing larger applications, the new Visual C++ 2005 is the power tool for Windows programming. In this presentation we’ll spend extensive time in the Visual C++ 2005 development environment – highlighting new productivity features – as we dive into its support for building high-performance, first-class native and managed applications.

What's New in C# 2.0
Kevin McNeish - NET287
This session provides real-world examples and explanations of the new C# language features, including generics, anonymous methods, iterators, and partial types. It also provides a preview of some great new code editor, debugging and IDE enhancements for the C# developer.

What's new in WinForms 2.0?
Kevin McNeish - NET299
The WinForms package has been greatly improved for Visual Studio 2005. This is true for existing controls that have been greatly enhanced. It is also true for new controls. It is true for data binding. And the design time experience has been greatly improved as well! And the list goes on and on. This session provides an overview of all the important areas that have been enhanced and/or changed.

What’s new in System.Xml V2
Christoph Schittko - NET275
The System.Xml namespace went through quite a bit of an evolution process since the release of the .NET Framework V1. Even through the course of the public beta process, the scope and the programming model of System.Xml V2 changed considerably from the state in the first public release of Whidbey at PDC in 2003.

This session presents the new features in System.Xml V2, changes to the programming model and related best practices as well as the new and improved tool support in Visual Studio 2005.

WinForm intuitives avec VS2003 et VS2005
Eric Moreau - NET233
This session introduces you to many aspect of creating friendlier user interfaces with Visual Studio .Net 2003 and 2005. Topics such as tooltips, error provider, status bar, help files (creation and integration) and MSAgent will be covered.


Mobile devices and Tablet PC

Building SmartPhone Applications with VS.NET
Rick Strahl - NET222
This session gives you the skinny on what you need to know to take advantage of MicroSoft SmartPhone devices and how to deal with the unique challenges that this platform presents. We'll look at the tools available today in VS2003 and tools coming soon in VS2005 and the Windows Mobile 5.0 SDK (Magneto). We'll also compare pros and cons of using Web based interfaces vs native SmartDevice applications for presenting user interfaces. We'll cover exposing functionality via Mobile Forms and using Smart Device interfaces. You'll see how to manage data locally and communicate with server applications via Web Services. We'll also discuss some of the issues that you are likely to run into during development. This session is an intro geared to introduce the platform and demonstrate common use scenarios from a business application perspective.

Developing occasionally connected CF applications
Sam Gentile - NET357
Developing Occasionally-Connected Mobile CF Applications with Whidbey Compact Framework 2.0

Today’s new generation of smart mobile applications must take into account that connectivity is often absent and continue to work anyway. In this session, we will examine occasionally connected principles and then use the Whidbey Compact Framework 2.0 to build a occasionally connected mobile application that uses the new SQL Mobile database

Real World Tablet PC Development
Markus Egger - NET289
You understand the basic ideas behind Tablet PC development? You have looked at all the silly little examples? And now you are ready to do some Tablet PC development for real? In that case, this session is for you. This session assumes that you are familiar with what a Tablet PC is and that you understand that the most important Tablet PC feature is pen-input, because in this session, we discuss how to use these things in real applications. This includes topics such as enabling an existing application for Tablet PC use, developing applications that work both in tablet as well as keyboard environments and providing a good user experience for both scenarios. The session also discusses how to manage and store digital ink and make that data available for both tablet and non-tablet users. This session also discusses user interface design issues to create applications that work for all kinds of users. These discussions are not just done from a design point-of-view, but the session also presents code examples and in-depth technical solutions.

What’s New in .NET Compact Framework 2.0 & VS 2005
Nickolas Landry - NET243
With even more great mobility features, Visual Studio 2005 brings us one step closer to the dream of business applications and data accessible anytime, anywhere and on any device. Learn all about the mobility enhancements and novelties in VS 2005 that pertain to the .NET Compact Framework 2.0, such as new UI controls, native interop, message queuing, improved support for online/offline applications, phone features, and various development tools such as Database tools, WYSIWYG designers, User Controls, Inherited Forms, debugging, creating Interop assemblies for native COM components, Graphical tools for creating Device CAB files, and more. Accompanied by great demonstrations of these new features and coding techniques, this is an essential session for any .NET developer intent on taking today’s applications into the busy ever-connected world of tomorrow.


Database Administration

Bare Metal Tuning
Kevin Kline - SQL230
Choosing and configuring the bare metal server, CPU, memory, networking, and hard disks for a major SQL Server installation can be daunting, especially if you've never done it before. This session will teach how to tune the 'bare metal' for a highly scalable, multi-user, high performance application running on SQL Server. This article will answer questions like:

-How do I configure my hard disks? Do I need RAID? If so, what kind is best for my application?
-What sort of networking configuration is best for my application?
-How much memory do I need? What's involved in configure many gigabytes of RAM for SQL Server?
-How do I deal with the new hyperthreading CPUs? How do they impact performance?
-What server platforms are best for my SQL Server application?
-What version of the OS and SQL Server should I install?

Setting up hardware can be very intimidating, especially when the application needs to scale. Learning the tips and techniques described in this session will help you avoid costly mistakes and serve as the foundation for the long-term success of your SQL Server environment.

Benchmarking SQL Full-Text Search Applications
John Kane - SQL311
Benchmarking traditional database application is a standard and well known practice today. Full-Text Search enabled database applications require different aspects of using these standard database monitoring and benchmarking tools as well as publicly available data in multiple languages in order to effectively benchmark FTS performance. Learn how to monitor and use SQL Server 2000, SQL Server 20005 and "Microsoft Search" Performance counters and combine this with other factors to allow you monitor and recommend hardware and software configurations. In this session, you will learn how to acquire, setup, and monitor FTS performance using a "standard" FTS Benchmark Tool Kit (FTSBTK). Leave this session understanding how to use this toolkit to recommend and correctly configure your FTS-enabled database application.

Beyond SELECT:Temporary Data Holders in SQL Server
Daniel LeClair - SQL101
Most developers are familiar with the basics of the SELECT statement for retrieving data in many Microsoft products. However, SQL Server’s T-SQL language contains many more commands and functions to help get the right answer in the fastest possible manner. In this session, we will cover one subset of these commands: how to capture data in temporary data holders (temporary tables, cursors, and table variables) for further processing, before returning the final result set. Easy to use – and also easy to abuse – temporary data holders are a powerful subset of the T-SQL language, and can help solve difficult problems when used correctly.

Attendees will learn about:

-Cursors – Using and Avoiding
-Dynamic SQL Statements
-UDF’s and the Table Variable Type
-CASE statements
-Derived tables

Database Mirroring in SQL Server 2005
Rick Heiges - SQL370
This session will cover Database Mirroring in SQL Server 2005 and the complementary technologies that go along with it. Other High Availability and Disaster Recovery methods will be discussed and compared such as Clustering, Replication, and Log Shipping. Transparent Client Redirect will also be discussed with this exciting new feature in SQL Server 2005.

Database Snapshots in SQL Server 2005
Rick Heiges - SQL371
A Database Snapshot is just what it sounds like it is, a picture of a database at a point in time. Explore how a Database Snapshot works and how it can benefit you as well as what it can’t do for you. We will also go over how to manage this new feature in SQL Server 2005.

High Performance DBA
Kevin Kline - SQL231
Truly high performance DBAs don’t work harder than other DBAs, they work smarter. In this session, you’ll learn how to set up and configure a SQL Server 2000 installation for maximum performance, reliability, and security. To accomplish this, we will discuss a checklist of steps that can be automated and performed every time a new SQL Server is deployed. The checklist, and the T-SQL script that automates the checklist, are covered in detail in this session and can save your hours of work per installation.

Highlighting the SQL Server 2005 Relational Engine
Adam Machanic - SQL280
SQL Server 2005 provides developers and DBAs with many new enhancements for indexing and performance. In this session we will discuss some of the more important relational storage engine highlights:

-Table and index partitioning
-Indexes with additional columns included
-Correlated datetime statististics
-Snapshot Isolation Level
-Indexed view enhancements
-Persisted computed columns
-Disabling indexes

At the end of this session you will have a clear picture of how and when to use these new features to drive development of more highly performant, scalable SQL Server-based applications. A working understanding of SQL Server 2000's indexing features is recommended but not required.

Hop on board the SQL Server Express
Rick Heiges - SQL270
Want to learn what the heck SQL Server Express is? How can using SQL Server Express help to develop scalable applications? How can SQL Server Express be used in the enterprise? These questions will be explored as well as an overview of the product and how it compares with MSDE and JET. SQL Server Express 2005 is a product with a lot of promise.

Performance Baselining, Benchmarking, and Monitori
Kevin Kline - SQL232
It's impossible to truly tune a SQL Server without a good understanding of its performance profile and work load. This session describes techniques and procedures to assess the baseline performance profile of a SQL Server, benchmark the performance of the server under varying work loads, and how to continuously monitor the server for maximum availability and performance. This session will help you:

1. Learn how to set up baselines, benchmarks, and monitoring
2. Understand the benefits and drawbacks of the two main approaches to monitoring
3. Learn major PerfMon counters that are important for baselining, benchmarking, and monitoring

SQL Server 2005 Security
Robert Hurlbut - SQL321
Security has been enhanced in SQL Server 2005. Schemas and synonyms will make it much harder for attackers to profile a database to plan an attack. SQL Server password can now take part in the password management system provided by Windows Server 2003. The execution context of stored procedures can be controlled more closely. This session will cover these new security features and more.

Understanding EXECUTE AS and Impersonation
Randy Dyess - SQL250
Often DBAs and developers will have to grant object level permissions to SQL Server tables in order to achieve the goals of a stored procedure. Microsoft has introduced two new concepts in SQL Server 2005 to help alleviate the management of object permissions. This session will cover how a developer or DBA can change the execution content of their code with the new EXECUTE AS feature of SQL Server 2005. Developers will learn how changing the execution context and user impersonation will allow them to provide a finer granularity of security in the newest release of SQL Server.

Understanding SQL Server Execution Plans
Randy Dyess - SQL150
Need to optimize your queries but do not know where to start? Have you been told to review the execution plan but do not know what to look for? In this session, you will learn how to review a stored procedure's execution plan to understand the flow of the stored procedure as well as determine likely areas needing to be optimized. This session will present a few of the top performance issues that are common in a large number of queries and how you can easily spot these areas by reviewing the execution plan for that query.


T-SQL Stored Procedure and CLR

Best Practices for SQL Server Development
Adam Machanic - SQL380
Traditionally it has been unnecessary for DBAs to observe development best practices -- and T-SQL certainly provides few constructs to assist those who have tried. As the line between DBA and developer continues to blur, structured database development becomes increasingly important. In this session you will learn best practices for ensuring stored procedure robustness with unit testing, how to implement a T-SQL-based assertion framework, and the basics of handling exceptions in T-SQL, including 2005's TRY-CATCH syntax. We will also discuss how much onus to put on SQL Server for handling its own exceptions.

Developing with SQL Server Notification Services
Adam Machanic - SQL381
Less Talk, More Code: A Practical Look at Developing with Notification Services

SQL Server Notification Services provides a powerful backbone for developing scalable subscription-based applications -- once you get past its steep learning curve. Unfortunately, the documentation currently available doesn't do justice to this new technology. Developers trying to get a handle on the product are pummelled with what feels like mere filler: Terms like "generators," "distributors," and "instances" -- accompanied by lots of pretty diagrams -- abound. But where is the actual code?

Enough with the architectural underpinnings! This session will cover Notification Services from a code-driven point of view. We will walk through creation of a simple application one step at a time and learn how to really use the product, stressing simplicity and real-world use cases. At the end of this session you will have a clear picture of how easy it can be to design an event-based system using Notification Services to send e-mails, write file-based notifications, and trigger many other types of messages to subscribers.

Déboguage de procédures stockées avec VS
Eric Moreau - SQL188
This session will start by introducing you the “Visual Database Tools” available from the Visual Studio .Net 2003 IDE. Then we will see how to debug SQL Server 2000 Stored Procedures from within VS.Net 2003 IDE and even while your code is running. The session will ends showing what Visual Studio 2005 (Whidbey) and SQL Server 2005 (Yukon) has to offer on this topic.

Implementing .NET code in SQL Server 2005
Peter DeBetta - SQL246
SQL Server 2005 now has the ability to use .NET languages when developing procedures, functions and other objects within the database. This session is the first of two parts that explores this new world of database development using .NET languages. In this session, the attendee will learn how to create stored procedures and user-defined functions in .NET and also learn the differences in .NET and T-SQL coding and when each language is better to use.

New T-SQL Features in SQL Server 2005
Peter DeBetta - SQL245
The incorporation of .NET into SQL Server is not the only new thing for a developer to be drooling about. T-SQL has been enhanced to include features such as pivoting data, better exception handling, recursive queries, an enhanced TOP clause, new data types, new set operators and more versatile statements and clauses in general. This session aims to explore these new features of T-SQL and to show how and when they will best be used by the database developer.

Optimize your stored procedures
Randy Dyess - SQL251
Optimize your stored procedures by avoiding recompiles

An often overlooked performance problem in stored procedures is the recompile. In this session developers and DBAs will understand the causes of stored procedure recompiles and the stress that those recompiles place on a system. Developers will come away with an understanding of stored procedure recompiles and how they can be avoided in future code.

SQL Server 2005 Managed Stored Procedures
Robert Hurlbut - SQL320
SQL Server 2005 has gone through many changes in order to host the CLR, and in turn, to allow developers to write managed stored procedures. This session will cover some of the history of those changes as well as what developers need to know to write managed stored procedures as well as understanding issues with Code Access Security.

Trapping Exceptions and Other Backtalk from SP
William R. Vaughn - SQL275
SQL Server stored procedures provide an important component in any sophisticated application. When the stored procedure needs to communication errors or other exceptions to the application it has a variety of exception handling routines from which to choose. This session discusses these techniques as well as describing the functionality of SQL Server stored procedures. We’ll also discuss how stored procedures function behind the scenes and generate resultsets, rowsets, OUTPUT parameters, XML resultsets, print messages, exceptions and a RETURN value. In some cases, it’s necessary to write information to the system log so we also show how to post information to the Event log. We also show how ADO.NET can be used to execute stored procedures as well as process the return values, OUTPUT parameters, and trap the info message events.

Working with User Defined Functions in SQL Server
Rushabh Mehta - SQL240
User Defined Functions in databases play a very important role in database development. Unfortunately, it also happens to be an under-utilized feature by database developers. UDF’s are fairly powerful and useful in a number of scenarios and ways… from encapsulating complex calculation logics and business rules, to allowing complex “views” on data. When used well, they provide a powerful mechanism to reuse and manage business rules in the database. The reusability aspect of user defined functions also permit easy maintenance of these business rules.

In this very basic session, you will learn how to create and use user defined functions in SQL Server 2000 and you will also learn of scenarios where they should not be used.


SQL Server Integration Services

Accès aux données en .NET depuis SQL Server
Guy Barrette - SQL225
If you’re developing .NET client applications using ADO.NET, you are familiar with the SQLClient classes. In this second presentation on .NET and SQL Server integration, you’ll learn how to SQLClient in code running on SQL Server like stores procedures.

Configuring and Deploying SSIS Packages
Kirk Haselden - SQL236
Moving packages around is perhaps one of the most problematic issues users must face when using DTS. Integrations services has introduced infrastructure for simplifying this process. This talk will describe what that infrastructure looks like, how to use the deployment, configuration and other features it provides to simplify package deployment. We’ll also touch on various best practices, tips and tricks.

Data Flow in SSIS
Kirk Haselden - SQL237
In this talk I will give an overall architectural review of the Data Flow capabilities of Integration Services. I will also drill down a little on specific features Integration Services provides for data flow. We’ll look at several important adapters and transforms including the flat file adapter, OLEDB adapter, Lookup, Conditional Split and others.

Intégration .NET et SQL Server
Guy Barrette - SQL177
In the first of three presentations on .NET and SQL Server 2005, you’ll see how it is possible to combine .NET programming with SQL Server using Visual Studio 2005 and SQL Server 2005. You’ll see how SQL Server is hosting the .NET CLR and how to code a user defined function in a .NET language like C# or VB.NET.

Managing Hierarchical and Tree Data in SQL Server
Peter DeBetta - SQL340
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 will show you how to design and implement these different techniques for managing hierarchical data structures in SQL Server.

What’s new in DTS
Kirk Haselden - SQL235
Everything has changed and DTS is now called Integration Services. The new name reflects Microsoft’s expanded approach to the ETL and integration space. While covering a few key philosophical changes, the more obvious feature changes and many of the new features, I’ll also cover what hasn’t changed so that experienced DTS users will have a starting point from which to begin their exploration of Integration Services.


SQL Server Business Intelligence

Advanced Full-Text Search Design Techniques
John Kane - SQL312
Do you want to know how to better monitor and manipulate the results of your SQL Server 2000 and 2005 Full-Text Search (FTS) queries? Are you hitting limitations in your FTS-enabled database application, either performance or functionality? In this session, you will learn how to enhance your FTS queries with real world advanced techniques and add "Intelligence" to your FTS queries. We will use advanced Information Retrieval (IR) and Natural Language Processing (NLP) techniques to improve your FTS query functionality as well show you how to improve your FT Indexing performance. Leave this session understanding how to expand and extend FTS to increase your FT-enable database application effectiveness.

BizTalk Server and SQL Server Service Broker
Sylvain Duford - SQL333
More details soon...

BizTalk Server as an SOA Platform
Sylvain Duford - SQL334
Implementing a Service Oriented Architecture (SOA) system based on existing legacy applications is one of today’s biggest challenges. More often then not, those existing applications do not lend themselves to being exposed as services. The difficulties range from simply interfacing with those legacy technologies to the granularity and tight coupling of the interfaces. In this session we will discuss what SOA is and how BizTalk Server can be used as your SOA infrastructure and enable you to repackage your existing applications as higher-level Services. We will discuss how various BizTalk features apply to SOA and enable you to concentrate on the business processes rather than the technical details of the existing applications.

ETL Design Best-Practices
Rushabh Mehta - SQL241
A number of simple best practices can be applied to an ETL design to ensure a low-maintenance and a viable ETL solution for an enterprise DW. These best practices have been developed during the development and deployment of multiple large Business Intelligence systems.

Introduction to Business Intelligence
Rushabh Mehta - SQL140
Business Intelligence is the ability of a system to derive knowledge from data. BI is not just limited to large corporations, but can also be used in small and medium businesses and at every level within our organization. Business Intelligence touches us every day in ways that we don’t even realize… from product recommendations on Amazon.com or Netflix.com to the daily weather forecasts that we see on the news.

In this session, we will look at the different analytics that is enables by Business Intelligence and we will also study the different components of a Business Intelligence solution and explore some technologies that can be used to enable BI within our organizations.

Roman Rehak Tech. Chair for the SQL Track
Roman Rehak - SQL000
This is not a session. Roman Rehak was the Tech. Chair for the SQL track. We like to thank him for is hard work done for the 2004 and 2005 events.

SQL Server 2005 Service Broker
Robert Hurlbut - SQL322
Service Broker is a framework built into SQL Service 2005 that greatly simplifies the creation of reliable, scalable, message-based, asynchronous, distributed database application. A service broker can manage business transactions, which in practice can last for hours, days or indefinitely and span databases. A Service Broker application consists of a set of services, queues, message formats, and dynamically created conversation. Any application that can make a connection to SQL Server or a web service can make use of a Service Broker application. This session will cover the basics of Service Broker and show the implementation of a Service Broker application.

Text Mining using SSIS
John Kane - SQL310
Text Mining is to un-structured data, what Data Mining is to structured data. Data Mining on Text (or Text Data Mining [TDM]) use similar analysis techniques as in traditional Data Mining techniques, such as clustering and association rules. Text Mining uses unstructured textual information and examines it in an attempt to discover structure and implicit meanings buried within the text. In this session you will learn how to use SQL Server 2005 Analysis Service and Integration Services to analyze textual data that can be combined to improve text analysis, Full Text Search and and used with Fuzzy Lookup Data Cleaning. Explore advanced uses for Analysis Services and how to expand your use of SQL Server 2005 into new and exciting applications such as Intranet Enterprise Search. You will leave the session understanding how to use TDM and get more out of your OLAP implementations.


SQL Server Reporting Services

Introduction to SQL Server Reporting Services
Dan Jurden - SQL222
SQL Server Reporting Services is a complete reporting engine, based on WEB Services, that provides developers a way to design, manage and deliver reports to end users. The name is a little misleading. It is called SQL Server Reporting Services because SQL Server is an integral part of the engine for storing and delivering report information. It does not mean that the report data must come from SQL Server. In fact the data can come from any ODBC or OLE DB data source. This session will give an introductory overview of the features provided by SQL Server Reporting Services.

Reporting Services for Architects, DBAs and Dev.
William R. Vaughn - SQL276
Microsoft SQL Server Reporting Services for Architects, DBAs and Developers

At long last, developers have a new Microsoft server-based reporting solution built from the ground up, almost completely but not entirely in .NET managed code. The session drills into the inner workings of Reporting Services so that architects, database administrators and developers can know how best to understand and leverage its features. This talk is extracted from the new book “Hitchhiker’s Guide to Microsoft SQL Server 2000 Reporting Services” (Addison Wesley) to be published this summer. The session includes extended demonstrations of the Visual Studio .NET Report Designer addin used to create dedicated and shared data sources, parameterized DataSets, layout and format report data and deploy the finished report to the catalog database. It also demonstrates how to manage reports and users with the Report Manager.


Developing with VFP 9.0

Big Things Come In Small Packages
Drew Speedie - VFP192
In each new version of VFP, there are always features or enhancements that seem to be "minor" items, because they don't need an entire conference session or two to explain. However, many of these one-line items in the What's New In VFP help topic are significant improvements that should not be overlooked. In this session, Drew explains and demonstrates a number of the "small" ways in which VFP has been enhanced recently. He will concentrate on new Small Packages in VFP 9.0, but, time permitting, he will include some VFP 8.0 and even VFP 7.0 items you may not have been using.

Bind VFP Code To Window Message Notifications
Drew Speedie - VFP244
The BINDEVENT() function was introduced in VFP 8 for binding VFP properties, events, and methods to delegate code. That feature supports better encapsulation, looser coupling, and simpler maintenance, especially when designing composite classes. In VFP 9, the BINDEVENT() function has been expanded to support binding to Window Message notifications from the Windows operating system. Now you can bind VFP code to events that Windows sends to VFP objects that have a window handle (hWnd), like _VFP, _Screen, and the base class Form. This session explains this new functionality, and features several examples including an abstract event-handler class and concrete subclasses. The demonstrations show how you can hook your VFP code to Windows system events like when the user changes the Theme, the desktop resolution, leaves/returns to your VFP application, unplugs his laptop, etc. Attendees should have experience creating VFP forms and controls; a basic understanding of the VFP 8–style BINDEVENT() is helpful.

Customizing the Property Sheet
Tamar Granor - VFP222
VFP 9 introduced MemberData, a way to specify attributes for properties, events and methods. This session will explore MemberData, the MemberData Editor and custom property editors, the most exciting aspect of MemberData.

Putting the Task Pane Manager to Work
Tamar Granor - VFP322
The Task Pane Manager, added in VFP 8, offers a wide variety of possibilities for customizing your working environment. This session will show you how to use the task panes supplied by Microsoft, how to add third-party panes, and how to build and distribute your own panes. The Data Explorer, new in VFP 9, will be covered.

Subclassing CursorAdapter for Flexible Data Access
David Stevenson - VFP361
Many developers have seen or read about the interesting and powerful CursorAdapter base class added in VFP8 and enhanced in VFP9. However, many may still be scratching their heads about how to properly fit the CursorAdapter into their typical project architecture. This session will go beyond the CursorAdapter’s syntax, properties and methods and will focus on using the CursorAdapter effectively through subclassing. This session aims to fill in the blanks of understanding and “turn on the light” for CursorAdapter’s usefulness in a variety of development scenarios.

Ten Practical Uses for the XMLAdapter
David Stevenson - VFP263
The XMLAdapter class and its related XMLTable and XMLField classes were introduced in VFP8 and enhanced in VFP9. This set of classes is one of the most powerful and least understood features of VFP. This session will illustrate at least 10 great use cases to leverage XMLAdapter’s strengths, and will show how the XMLAdapter, XMLTable and XMLField classes can handle just about any XML task thrown at them, including several that you may have never considered. Attendees will not only see practical uses for the XMLAdapter, but will learn its most important properties and methods in the context of real-life examples.

Test-Driven Development in VFP Using FoxUnit
Drew Speedie - VFP191
Throw away your crash helmet and go to bed knowing your code is clean! This session provides an overview of Test Driven Development, while focusing on unit testing with FoxUnit. FoxUnit is a new, free, open-source XUnit-style testing framework for Visual FoxPro developers. FoxUnit offers most features found in commonly available XUnit derivatives such as JUnit and NUnit. FoxUnit also provides a number of developer productivity enhancements and other features that are unique to FoxUnit and Visual FoxPro development. Drew Speedie will take you through real-world examples of test-driven development he has done using FoxUnit. Learn how and why to test your code before you write it!

Using Internet Explorer in your FoxPro Application
Rick Strahl - VFP376
Find out how to integrate Internet Explorer into your applications by using the Internet Explorer COM object and the Web Browser ActiveX control. This session starts with the basics of displaying Web and local HTML content and then delves into more advanced topics such as controlling and interacting with the IE document model (DOM) to manipulate and exchange data between the browser and your application. We'll also take a look at HTML editing using the control. This session is full of short examples and a handful of practical real world uses for this technology in running applications.

Using VFP 9's SQL commands
Tamar Granor - VFP223
VFP 9 includes quite a few enhancements to Visual FoxPro's SQL sub-language. Many of the limits in queries have been removed and subqueries are allowed many places they previously weren't. This session will show you when and how to take advantage of these changes.


Migrating from Win32 App to .NET App

Accessing VFP Data in Other Applications
Daniel LeClair - VFP331
Use the VFP OLE-DB Provider within SQL Server and other apps

You’ve probably read or heard a lot of information regarding migration of VFP data to SQL Server. But what if you aren’t ready (or don’t intend) to move? VFP’s OLE-DB Provider gives other applications access not just to data, but other DBC events and stored procedures as well, and in this session we will explore the interfaces that are available to you.

Attendees will learn about…

-How to access VFP data from external
applications -How to use, create, and modify stored procedures
-Creating and modifying DBC’s with the Data Manipulation Language (DML)
-What VFP commands and functions are (and are not) supported by the OLE-DB provider
-What’s new for the OLE-DB provider in VFP 9

Converting your VFP application to use SQL Server
Les Pinter - VFP243
In this session, you'll learn the technique for converting a FoxPro application to use either DBFs or SQL Server, as described in Les Pinter's book, Visual FoxPro to Visual Basic .NET. The session will include utilities for planning and executing the conversion. A utility will be presented that audits FoxPro code and documents all instances of commands and functions that require different treatment when using SQL, as well as a middle-tier class that can be used to build a bridge to SQL Server in your FoxPro app without breaking your existing code. You will leave the session with a sample application that switches between DBFs and SQL Server with a single change to an .INI file.

Data access in .NET for VFP developpers
Les Pinter - VFP241
In this session, you'll learn about the disconnected data approach used by .NET and how it changes the way a FoxPro developer has to view data. You'll learn about datasets, the .NET equivalent of FoxPro cursors. Since datasets are the only way you can contain tabular data within your applications, filling them, then using them to construct INSERT, UPDATE and DELETE statements that interact with your data source, looks complicated compared to the FoxPro equivalent, the USE statement. The good news is that you'll learn how to abstract data interaction so that you never again have to think about the actual mechanics of data interaction again. You'll also learn how to implement equivalents for APPEND BLANK, GO TOP, SKIP, TableRevert() and TableUpdate() and other FoxPro data-related commands and functions that don't have system-wide equivalents in .NET.

Migrating from VB to VB.NET – Part I
Ed Musters - VFP288
You still have a substantial investment in Visual Basic applications, and you are finally making the long awaited move to VB.NET! Don’t worry, you are not alone and we are here to help! First we will look at the upgrade options and considerations. We will take a detailed tour of the VB.NET upgrade wizard, the upgrade report, and common problems and resolutions. We will examine COM interoperability and see how COM is called from .NET and .NET is called from COM. Next, we look at migrating your current architecture to .NET – this includes the presentation layer (ASP to ASP.NET), the business, and data tier. We’ll look at considerations such as web services wrappers, .NET Remoting, and use of Typed Datasets.

Migrating from VB to VB.NET – Part II
Ed Musters - VFP388
In this session, we will examine capabilities of VB.NET that were either extremely difficult in VB or simply not possible. As you move to VB.NET you will want to leverage these features! We will first look at form layout and control enhancements, as well as structured exception handling. Then we will look at more advanced programming such as creating windows services, performance counters, role based security, event logs, and application configuration files.

Migrating VFP Data to SQL Server
Daniel LeClair - VFP233
The VFP Upsizing Wizard is a great way to convert simple VFP databases into MS SQL Server. But what if your needs are more complex? SQL Server offers several ways to port data in and out, but VFP – with its native data engine – can also do the job, if you are prepared to write the code. Which way is best?

In this session, we will compare the costs and benefits of using the VFP Upsizing Wizard, SQL’s Data Transformation Service (DTS), and creating your own custom VFP conversion application using SQL Passthrough for bulk-data loading into SQL Server.

Attendees will learn about...

-The VFP Upsizing Wizard
-SQL BCP and Bulk Insert
-SQL Data Transformation Services
-Using custom VFP code for data conversion

NET for FoxPro Developers
Les Pinter - VFP242
A summary of the main features of .NET that FoxPro developers need to do the same things we do in VFP. In this session, you'll gain insights into what features exist in .NET that are most similar to what you're already doing in Visual FoxPro, as well as the features of .NET that are most foreign to FoxPro developers. In the process, we'll distinguish between what you actually have to master and the things you'll probably never use. We'll build a small but useful application during the session, using techniques similar to those used in FoxPro apps. Jump-start your .NET career. This is a 1-hour summary of Les Pinter's new book from SAMS Publishing, Visual FoxPro to Visual Basic .NET.


Rearchitecting Win32 Applications

Converting your VFP app to Business Objects
David Stevenson - VFP262
What are the principles involved in converting a FoxPro application to Business Objects? We’ll start at the beginning and build up a set of basic Business Object classes which attendees can put to use immediately after the session. This session will deal with the thorny issues of making an existing application work with new concepts and paradigms without a complete rewrite. We’ll cover a list of do’s and don’ts as well as illustrate the end result of a more maintainable and extensible application, using the business objects in a desktop app, a web page, and a web service. VFP9’s improved XMLAdapter will be used in some of the examples.

DataSet avec Visual FoxPro et XmlAdapter
Rock Legendre - VFP252
With its new .Net platform, Microsoft favors the use of XML as a means to transfer information among Web services. Thus, DataSet XML representation is essential to Web services users. Consequently, in developing version 8.0 of Microsoft Visual FoxPro, the development team aspired to make Web services and XML, including DataSet XML representation more user-friendly. In this workshop, we will exploit the new classes, such as XMLAdapter, XMLTable and XMLField, which facilitate our work when developing Web services.

n-Tier in practice – TierAdapter Framework
Martín Salías - VFP272
Goals: Introduce VFP developers to the TierAdapter Framework and its usage
- N-Tier applications overview
- TierAdapter overview
- Sample application
- Application components
- Application-level subclasses
- Building applications

Passing data trough tiers
Martín Salías - VFP273
Goals: Present VFP developers with alternatives to build n-Tier applications
-The problem with data access trough tiers
-Data Sessions and isolated processes
-Alternative data communication mechanisms
-Arrays
-XML
-ADO
-Objects
-CursorAdapter Class
-The universal connection: XML
-XmlAdapter Class

Putting Your VFP App on the Web
David Stevenson - VFP261
In this session you will learn how to bring your FoxPro applications into the Internet world. Several approaches will be discussed and illustrated, including accessing FoxPro tables through OLE-DB from an ASP.NET web page, calling Visual FoxPro DLLs from a web page, and using any of several web frameworks to run your FoxPro code and generate HTML. Special attention will be paid to issues of state and statelessness as they apply to web and distributed applications. You will leave this session with a better understanding of why you can’t just “make this app run on the web” and will see several proven techniques to come close to that dream.

SOA and Web Services with VFP
Martín Salías - VFP271
Goals: Introduce VFP developers to Service Oriented Architectures and Web Services

• Service Oriented Architecture (SOA) overview • Connecting disparate systems and applications

-SOA and OOP
-Consuming Web Services in VFP
-Building and publishing Web Services with VFP
-Deployment issues
-Design Considerations – Coarse grained functionality


Win32 App with Windows COM+ / Event Log

Advanced COM Development (VFP)
Martín Salías - VFP274
Goals: Improve VFP developers' abilities to leverage COM technology

-Creating COM components (an overview)
-Threading models
-Type libraries
-Interfaces
-Binding events
-Powerful VFP COM Servers

Using the Windows Event Log
Craig Berntson - VFP256
Many Visual FoxPro applications use text files or DBFs for logging application errors. However, Windows provides a central location for these errors. It’s called the Windows Event Log. In this session you will learn you should use a common error message repository and how to use the Windows Event Log with Visual FoxPro.

Attendees will learn:

-The event log message format
-How to read messages in the event log
-How to add messages to the event log
-How to manage the event log message store
-Techniques for using the Windows API

Windows Component Services (COM+), Part 1
Craig Berntson - VFP255
This session gives an overview of COM+ services, beginning with the basics of COM and how component design changes under COM+. It then moves into creating COM+ components and how to administer COM+ applications and security. It concludes with transaction management using the Microsoft Distributed Transaction Coordinator.

Attendees will learn:

-What is COM+ and why you want to use it
-How to create COM+ components in VFP
-How to install and manage COM+ applications and components on both the server and client
-How to setup and use COM+ security
-How to use transactions under COM+

Windows Component Services (COM+), Part 2
Craig Berntson - VFP355
This session discusses some of the advanced features of COM+, such as Queued Components and Loosely Coupled Events. Also, Compensating Resource Managers that allow Visual FoxPro data to participate in COM+ transactions is also discussed.

Attendees will learn:

-How to use Queued Components to create offline, asynchronous applications
-How to use Loosely Coupled Events
-How to create Compensating Resource Managers that enable Visual FoxPro data to participate in COM+ transactions
-What other COM+ features, such as such as Object Pooling and Load Balancing, are available


Vendor sessions

DataClas/NET
Jim Duffy - VEN237
co-presenter Rod Paddock

DataClas/Net is a powerful, middle-tier business object designed to make accessing and maintaining your SQL Server data quick and easy. Unlike other middle-tier tools, DataClas/NET is not a code generator but rather a inheritable and extendable data object class.

Find and Fix Bad SQL
Kevin Kline - VEN233
The most common source of database performance problems is poorly performing SQL. Knowing that performance is suffering is important but quickly identifying which SQL is performing badly and tuning it is traditionally a skill found only at the database “wizard” level.

SQL Server Domain Expert, MVP, and PASS President, Kevin Kline, will demonstrate the challenges with finding and fixing bad SQL in SQL Server 2005. The demonstration will highlight:

-Detecting poorly performing SQL and its impact on database performance
-Automatically rewriting SQL to find faster alternatives
-Examine execution plans and cost numbers to chose the fastest, most optimized SQL statement

This session will enable SQL Server DBA's to optimize SQL Server performance by finding and fixing bad SQL.

Informal VMP Developers' Meeting
Drew Speedie - VEN243
Drew Speedie will host an informal meeting of Visual MaxFrame Professional developers. We'll discuss what's under construction in VMP, take a look at cool app created with VMP, and Drew will entertain questions about anything VMP, technical or otherwise. This is an 'informal' meeting, so we'll discuss anything you attendees want. You don't have to be using VMP to attend – anyone interested in VMP is welcome.

The Mere Mortals .NET Framework
Kevin McNeish - VEN300
The Mere Mortals .NET Framework helps you climb the .NET learning curve by providing a high-level Framework for building business applications. Many of the building blocks you would otherwise have to design and create yourself such as business objects, data access classes, database manager, security manager, and so on, have already been built for you as high-performance, reusable components in Mere Mortals .NET. This session demonstrates how Mere Mortals .NET teaches you best practices through its solid, object-oriented architecture, documentation and sample applications, and how your .NET Windows Forms, ASP.NET and Smart Device applications immediately benefit from the solid foundation supplied by Mere Mortals.

West Wind Html Help Builder
Rick Strahl - VEN232
Documentation of an application for both the developer and end-user is always the last thing on developer's minds, but it's a final piece that makes an application professional from a user's point of view and more maintainable from a developers point of view. HTML Help Builder makes short work of generating HTML Help files and documenting your applications both for end user and developer documentation. Help Builder's unique approach that focuses on content creation makes you more productive when creating help content. Help Builder separates content from design by using templates that merge topic text with customizable HTML providing a consistent look and feel to your help file. It's an easy and very productive environment for content creation.

And if you're a developer you'll love Help Builder's one-click support for importing types from .Net, COM and Visual FoxPro. You can also import and auto-document SQL Server and Visual FoxPro databases automatically. Help Builder is a fully automatable COM server that allows you to hook Help Builder into your development environment of choice or populate help files dynamically. When you're done generate output for HTML Help files, plain HTML for professional display of your documentation on your Web site, and to Word 2000 or later for a printed version.

In this Session Rick Strahl demonstrates how to create an HTML Help project from sratch with Help Builder. We'll create a sample help file for a typical development tool that demonstrates both end user documentation and developer documentation for classes and databases. Rick then demonstrates how to hook up the help file in both .Net and Visual FoxPro as well as demonstrating design time integration.

West Wind Web Connection for Visual FoxPro
Rick Strahl - VEN234
Web Connection is your one stop Web and Internet Tool solution for Visual FoxPro. It's powerful Web Application framework for Visual FoxPro that is built with developer needs in mind and takes you quickly from concept to implentation. It's a powerful and extensible framework of VFP classes that is nevertheless easy to use - writing Web handler code is as easy as creating a class and adding a method. Wizards help with setup and get you up and running in minute. The powerful classes provided in the framework greatly reduce the amount of code needed to generate HTML or XML output. Choose between using pure VFP code to generate output, or use external templates and to manage the HTML content via scripts with ASP style VFP code. In addition to HTML based interfaces Web Connection also includes support for Web Services, and distributed applications inluding client side tools for HTTP access, SMTP/POP3 and socket support. The library is rounded out by a number of tools that are needed for the Web and general application development process.

In this session Rick Strahl, author of Web Connection takes you through creating a small application with Web Connection starting with the basics of creating a new project and adding simple data display and editing using pure code. The sample then demonstrates how to mix VFP class code with external HTML templates to manage the visual aspects of the applications. In the process of this sample a number of general Web application principles are demonstrated so this session is also useful as an introduction to Web development in general.






Copyright © 2003-2009, DevTeach Inc., All Rights Reserved, Hosted by DevTeach inc. - Privacy Policy
.NET Conference 112 de Roquebrune, Gatineau, Quebec, J8T 7Y5 .NET Training
Telephone: 1-866-913-0430 Fax: 1-819 205-1422 Email: Info4You@devteach.com