Achieving Persistence Ignorance with NHibernate

Object-relational persistence can be very complex and middle-tier code is often dominated by persistence concerns. Your Customer class probably contains more code related to loading and saving customers to the database than it does actual business rules about customers. Wouldn't it be nice if you could remove all this persistence-related noise? This session examines why the concept of persistence ignorance is important and how to use NHibernate to build persistence ignorant domain models.

Taming Software Dependencies with DI and IoC

Software inevitably contains dependencies. Dependencies between classes. Dependencies between layers. Dependencies with third-party libraries. How can concepts like dependency inversion, dependency injection, and inversion of control help you tame your software dependencies? Where does an inversion of control container, such as Castle Windsor, come into the picture and do you need one? Can Binsor help you achieve convention over configuration? This session answers all these questions and more...

To C# 3.0... And Beyond!

C# 3.0 introduces lambda expressions, extension methods, automatic properties, and a host of other features. We will look at where C# is today, where it is going tomorrow, and what ideas we can borrow from languages like F# and Ruby to improve our C# code. Plus find out the real reason for the new "var" keyword.

Simple Patterns for Simple Problems

Everyone has that little (or not so little) class called Utility that holds all kinds of intersting bits of business logic. It is a hodge-podge of code that you're not sure where to put. This session will examine some common types of methods found in utility classes and how to refactor your design using simple patterns to eliminate these troublesome kitchen-sink classes.

OO Principles: Beyond Encapsulation, Inheritance, and Polymorphism

Any developer worth their salt knows these pillars of object-oriented programming, but there is a lot more to good object design. This session explores the fundamental principles of design patterns, including low coupling, high cohesion, single responsibility, open-closed, and other principles that lead to better software designs.

Queuing and Caching to Scalability

Performance and scalability are two sides of the same coin, but subtly different. Performance is about raw requests per second or similar measure, whereas scalability is about how performance changes as load increases. How can you keep your application - be it website, web service, smart client, or other - responsive as the number of users increases. This session will explore queuing (MSMQ and WCF) and caching techniques for scaling out applications and will examine architectural strategies for minimizing scale-out cost.

ASP.NET Kung-Fu: Advanced Techniques and Idioms

Unbeknownst to most developers, there's a lot more to ASP.NET than ASPX pages. In this session, James will explore some advanced techniques in ASP.NET including: HttpModules for modifying the run-time behaviour of your website; HttpHandlers for serving up non-HTML content; security context manipulation; and other fun topics.

Tools of the Trade: Must-Have .NET Utilities

The number of .NET development tools available is extensive and can be quite daunting, but there are a few that should be in every developer's toolbox. James will examine a wide range of freely available tools including "The Holy Trinity" (NUnit, NAnt, and NDoc), source control, continuous integration, static and dynamic code analysis, debugging, and related tools. The talk will include numerous demonstrations as well as discussion about the practical application of these tools to a development project.