Technical Sessions

Agile Is More Than Monkey-See-Monkey-Do - Peter Provost & Brad Wilson

In the six years since the Agile Manifesto was signed we have seen an upswelling of interest in agile techniques. Scrum Masters are everywhere and everyone wants to talk about TDD and other agile practices. But it seems that the pragmatic essence of agile development is being lost. A vast majority of talks, tutorials, and speeches at conferences over the past year or two seem to have lost that same essence and have instead focused on practices instead of principles. The goal for this presentation is to explain why it is the essence of agility that is so critical, so important to the success of any project trying to succeed. ?People over Process, Collaboration over Contracts, Working software over Written Words, and Planning over Plans? are not hollow words to an experienced agilist ? they are the lifeblood of what they believe and color how they act.

Building Services with patterns & practices - Don Smith

There are clear advantages of using a modeling environment when building services. The development team has more flexibility when the modeling environment includes logical models that don?t force platform and language decisions too early in the project. When this environment has a great deal of extensibility, the capabilities are only limited by imagination. The Web Service Software Factory: Modeling Edition provides this type of modeling environment. Attend this session to see how the Service Factory can be used and extended by your service development team.

Continuous Integration and Defense in Depth - Ade Miller

Continuous integration (CI) is the practice of building your whole product and running tests as frequently as possible. CI is one of key agile practices but is becoming a more and more common practice both throughout the software development industry as a whole. CI is not just for agile teams. So what is CI and why do it? What tools are available for setting up a CI server and how do I create a build and test it? Once your team has a CI server there?s a lot more you can use it for. Adopt a Defense in Depth approach to drive quality across your product and measure progress.

Decrease Coupling and Raise Cohesion - Mario Cardinal

This presentation presents simple but well proven design principles that simplify managing dependencies between elements composing a .Net program. During this presentation you will understand why architects worry so much about coupling and cohesion. We will terminate the presentation with a discussion about a static code analysis tool that enables architects as well as developers to easily identify problems with coupling and cohesion.

Dependency Injection Frameworks - Brad Wilson

Dependency injection is a way to achieve loose coupling. The technique results in highly testable objects, particularly when applying test-driven development. In this session, we'll examine the reasons behind dependency injection, and preview the changes coming in ObjectBuilder 2.0. We'll show two sample containers, including one that behaves like Castle Windsor. Finally, we'll examine the new method interception system that allows a limited form of Aspect-Oriented Programming when using ObjectBuilder 2.0.

Designing for Operations - David Aiken

This session features in-depth coverage on Windows and .NET management technologies and tools. You will come away with with concrete guidance on how to instrument applications, how to design a health model, and how to flow this through to IT operations.

Windows Workflow represents a completely different style of coding, one which utilizes a different style of programming than what we’ve seen before. Known in some circles as continuations, Workflow essentially provides the ability to serialize an executing thread, store it for a period of time, then restore the thread in a different environment or time for further execution. In this presentation, we’ll examine how Workflow does this (with your help), and how it can be used to solve some interesting design scenarios.

Empirical Evidence of Agile Methods - Grigori Melnik

Agile methods have come of age. Recent surveys indicate that agile methods (including Scrum, eXtreme programming, Lean development, MSF Agile, DSDM, FDD, ASD) are being adopted or seriously considered for adoption by many organizations. Practitioners want to know which individual agile practices work and do not work, and under which conditions. Existing data on agile methods and practices analyzing their claimed merits will be presented. This empirical evidence can also be used by leaders who need to evaluate agile methods and motivate their adoption. It may help implement changes in your organization with more confidence.

Enterprise Library - Grigori Melnik

The patterns & practices Enterprise Library is a library of application blocks designed to assist developers with common enterprise development challenges. As a set of guidance for meeting these challenges, this will cover changes made in the EntLib Refactored project on CodePlex.com. It focuses mainly on simplifying the code and changes based on 3 versions of learning and feedback.

Evolving Client Architecture - Billy Hollis

We are past the point as architects that we can assume that one user interface technology will be used in our applications throughout the application’s lifetime. Some applications needs multiple types of user interfaces today. Others will need to grow to accommodate the world of Rich Internet Applications in the next few years. This session discusses the architectural challenges in creating applications that are capable of supporting multiple UI technologies, and in creating rich client applications with more capability and logic than typical HTML-based user interfaces of today. We’ll look at the necessary patterns, such as Channel Adapter, Command, Observer, and Model-View-Presenter to see how each can be applied to rich Internet-based applications to create applications that are loosely connected and agnostic about data sources and data transports. We’ll look at layering the client systems when using technologies such as WPF and Silverlight, and how to properly take advantage of state on the client. And we’ll discuss some of the attributes of .NET that make it cost-effective to create applications that simultaneously support multiple user interface technology stacks.

The Future of Model-Based Design - Peter Provost

Models are an effective way to manage the complexities of application evolution and design. Future versions of Visual Studio Team System will include is building out an integrated set of designers which help allow you to visualize and evolve your existing code towards a target architecture using a best practice based approach. Integration between designers and Team Foundation Server TFS enable you to flow information between models, code and team members involved in the SDLC. Cutting edge code and metadata visualizations let aide you in comparing compare your actual code with the intended design to guide your application evolution. Team factories, based on specific application types, can be plugged in to guide you through the construction process and jump start your development efforts. This session will provide you with an overview of some of the efforts going on inside Microsoft to empower the code based developer and architect with next generation tools.

Future of patterns & practices - Don Smith

Lessons Learned from the CSLA Framework - Rocky Lhotka

Designing and evolving a development framework over time can be very challenging. The CSLA framework is used by thousands of developers around the world, and has been evolving for over a decade. The framework strives to be easy to learn and use, and yet has become more and more feature-rich over the years, which almost always increases complexity and decreases ease of use. In this session you'll learn about the painful tradeoffs made between new features and backward compatibility, between usability and functionality and more. This frank discussion will lay out the hard choices that have been made, along with their rationale - choices you may have to make if you design or assemble a framework for use within your organization.

Lessons Learned in Unit Testing - Jim Newkirk

It has been over 5 years since the first release of NUnit 2.0. In that time there have been literally millions of tests that have been authored. Some of these tests have become invaluable resources for their teams. Others have not been maintained and were viewed as failures. This session will describe some of the patterns that improve the usefulness of your tests as well as highlight key anti-patterns.

Managing Software Complexity - Billy Hollis

What?s the biggest problem facing architects and developers today? Billy Hollis believes that it?s the extreme and ever-increasing complexity of the technologies we use as platforms. In this session, Billy will look at the signs that complexity in software development is getting out of hand, and how existing practices are not up to the task of dealing with that challenge. He doesn?t pull punches; some sacred cows come in for rather severe criticism. Then he?ll venture some ideas on dealing with complexity today and what changes in the industry are needed long term to counter the problem.

The Patterns of patterns & practices - Ade Miller

Examining implementation of design patterns can give you tremendous insight into how to apply them in the solution you are building. The patterns & practices factories are a rich source of examples of implementations of many software patterns. This session will explore their evolution of some of the most common and useful patterns including dependency injection, chain-of-responsibility, MVP, container hierarchy, proxy, and more.

Revisiting the Data Layer - Guy Barrette

Let’s face it, most if not all the enterprise applications you’re architecting involve retrieving some kind of data stored in a relational database. For years we’ve been designing our applications into logical layers, one being the data access layer where the data access code is located. That layer was supposed to shield the application developers from the changes occurring at the database level but the reality is that we usually create strong coupling and dependencies between our layers. In this talk, we will see how to design a better decoupled data access layer. We will also look at some exciting new advancements in data access technologies and see where it make sense to use them.

"The Agile Talk on Open Source" - Peter Provost & Brad Wilson

One of the best ways to learn about agile software development is by doing it. This talk will be facilitated using an agile project management approach to prioritize and answer questions from the audience by a panel of agile and open source experts. Experience agile first hand and get your open source questions answered at the same time.

The Right Tools for the Right Job - Rocky Lhotka

It seems like building applications keeps getting harder, not easier. The technology options to choose from keep multiplying, and each of them is billed as the answer to everything. Should you use object-oriented concepts, service-oriented concepts or maybe workflow? Or do you go with SOA or n-tier client/server, and is there even a difference? The reality is that you may need to use any or even all of these technologies. Each one is designed to solve a specific problem space, and is a weak solution for other problem spaces. Join Rockford Lhotka in a pragmatic discussion about when to use all the technology options at your disposal.