Or maybe it should be titled: Agile for Dummies. For those that are new to agile or need a quick refresher, this session provides a broad introduction to the Agile world. There are a lot of misconceptions about what agile is and what it isn’t…you should have a better understanding after you leave. We will cover a brief history of agile, discuss some of the most popular agile methods and techniques, and touch on implications to organizations.

Organizations are increasingly moving from traditional waterfall methods of software development to agile methodologies.  Scrum has emerged as one of the most commonly applied agile practices.  Today’s successful software projects implement at least some aspect of Scrum.

This presentation guides participants through every characteristic of Scrum, including roles, planning, artifacts, and most importantly, the motivation behind implementing these elements.

If things go according to plan, we estimate that by the end of this session you will have:

• Written at least one user story
• Broken down a user story by tasks and scenarios
• Estimated effort using relative sizes and ideal hours
• Planned for a release
• Discussed why we estimate and why we plan

And we will have demonstrated how to:

• Track planned work items and estimates using TFS
• Use reporting in TFS to gain insight into the health of your project

Is your agile team just going through the motions?  You learned processes, and installed tools.  What are you doing about individuals and interactions?

Through the Agile Team Workshop, you and your team will learn to:

• Capitalize on individual strengths
• Optimize roles and assignments
• Communicate and collaborate
• Attain peak performance
• Enjoy working together

Lean/Agile–Maybe you’ve heard about it, read about it, or even tried it out.  Maybe you don’t agree with every aspect of Lean/Agile software development, or you doubt that it will be the best fit for your particular project or organization. This seminar aims to dissect and de-mystify the process in an interactive experience comprised of lectures, candid discussions, exercises, demonstrations, and a few surprises. Come equipped with your specific situations and concerns about Lean/Agile adoption and software development processes in general.  With your input, we will engage in a candid interchange with the goal of outlining a set of best practices and adoption techniques tailored to your individual situations.

Objectives:

• Describe the core values
• Define and describe terms and concepts
• Distinguish between theory and actionable practices
• Describe roles and responsibilities
• Understand similarities and differences between various methods
• Avoid common traps and pitfalls

In this collaborative session, we will present a bit of theory and a bit of technology about requirements for agile development.  For years User Stories have been a popular way to indicate requirements, but only recently have acceptance criteria emerged as important adornments to them.  Come prepared to learn why, participate hands-on, and to see how TFS helps support User Stories and Acceptance Criteria to make agile Teams win.

The key ingredient to successfully developing quality software is communication. Through the years, lines in the sand have been drawn and battles have been fought over the appropriate forms and level of detail to use when documenting requirements specifications.

Describing the structure and behavior of a business domain is very closely aligned to the skills of successful mapmakers. Magellan, Vasco De Gama, and Columbus all demonstrated the value and usefulness of quality maps. While their stories about their travels were probably fascinating, the maps developed by their cartographers provided sustainable concrete records that were informative and helpful to others who followed.

As you navigate the treacherous waters of software development, quality maps can accelerate the journey and raise the quality of the results. In today’s information intense business world, there are limits to how much information can be communicated productively. Proper choices can lead to quality results, while poor choices can lead to disasters. There are a plethora of tools and techniques available to today’s business mapmakers. In this presentation, demonstrations and examples will be provided of a variety of techniques, along with a survey of popular tips and best practices.

What is Quality? What are its measures? When can and should it be measureable? We know that an agile project’s highest priority is to: “satisfy the customer through early and continuous delivery of valuable software”. We will explore when and where quality can begin to address the quantitative value of deliveries during the life of an agile project. Collaboratively working with the Product Owner to ensure that the Business Owners receive the value they expect.

Conventional wisdom says that ambiguity in requirements is bad.  But in an agile project it is good, at least for a while and in the right measure.  Come learn how your teams and your customers are ultimately better served by the right amount of ambiguity. Topics include the principle of delayed commitment, and how acceptance criteria fit in.

Merely using an object-oriented language does not guarantee that the solutions you create are high-quality, flexible, and easy to maintain.

This presentation introduces the concepts of Test Driven Development (TDD) that allow us to create robust regression tests and good code. TDD is often mistaken for simply writing automated regression tests against an existing design. The deeper truth is that TDD is first and foremost about incrementally specifying, implementing, and improving your software’s design.

Test-driven development takes development to the next level by forcing a tight cycle of red-green-refactor. Behavior-driven development pushes the methods even further. It has been said that Behavior-driven development is test-driven development done correctly.

You’ve been hearing an awful lot about type mocking recently, but what is it, and why should you care?  This presentation will answer these questions and is intended to serve as a primer to those interested.  In order to further decrease the learning curve associated with this relatively new technique, a live demonstration will be given showcasing the latest version of Rhino Mocks, built specifically to take advantage of the .NET 3.5 framework.  By the end of the presentation, you will understand how, through the use of mocking, you can potentially increase the consistency, integrity and speed of your unit tests dramatically.

When most people think of Continuous Integration (CI), they think of automatically compiling and unit testing their software on a central build server each time someone checks-in files to source control. We will go beyond the basics and discuss solutions to problems teams face when they start using CI. Our discussion will include CI best practices, what behaviors to avoid, and how to implement CI using Microsoft Team Foundation Server.

Patterns talks tend to be abstract, academic discussions rather than real world examples but not this talk. We’ll cover techniques you can use right now to refactor your current web application and implement a couple of patterns to create a more maintainable and testable code base. We’ll do all of this using an actual working web application – no “Hello World” garbage here!

If you’re a TDD practitioner, you’ve potentially faced the problem of over-specifying or under-specifying behavior in your system under test. Too many tests can create waste and become a maintainability nightmare. Too few tests leave your system susceptible to quality and maintainability issues. This session assumes familiarity with Test-Driven Development and introduces developers to another way of writing tests in .NET using a behavior-driven style and tools like NSpec and NBehave.

Session Outline:

• Review TDD and discuss potential frustrations
• Introduce the BDD approach
• Compare/contrast TDD and BDD styles
• Introduce BDD tools
• Demonstrate BDD tools on a simple problem

Naked Planning is a project management methodology that focuses on value rather than cost and emphasizes continuous delivery over iterative development. To traditional agilists with years of experience in incremental development using Scrum or XP, some of the ideas in Naked Planning may seem heretical. The approach is built on lean principles of pull and flow and provides a flexible framework to allow a quality team to rapidly produce quality software.

Session Outline:

• Cost-based planning vs. Value-based planning
• Why estimates don’t matter
• Lean concepts of pull and flow
• Naked planning description
• Naked planning demonstration

The next version of C# contains a host of new features that will power the next generation of .NET applications. This session will be a code-centered demonstration of C# 4.0 features and how they might improve your next application.

Session Outline:

• Introduction to C# 4
• Dynamic languages and the dynamic keyword
• Optional and named parameters
• Covariance and contravariance

ASP.NET MVC is the newest way to build web-based applications on the .NET platform.  This talk will explore the advantages of the MVC approach, how to build your first ASP.NET MVC application, and how to improve it through features from MVC Contrib and ASP.NET MVC 2.0.

Session Outline:

• Introduction to MVC
• Demo construction of a simple ASP.NET MVC application
• Add components of MVC Contrib
• Review and demo of ASP.NET MVC 2.0 features

Personal productivity is out of scope in most agile discussions, but one of the most significant ways to improve the productivity of a team is to improve the productivity of its members. This talk will discuss ideas from GTD and productivity experts and investigate how these lessons can affect and improve the effectiveness of Agile teams.

Session Outline:

• Factors that affect productivity
• Introduction to GTD
• Applying GTD concepts at the team level
• Productivity Utopia

As much as we learn and as hard as we try still many of our software projects fail. Hundreds or thousands of factors combine within a team or an organization to cause failure or inefficiency, but a large percentage of projects I’ve seen fail failed because of unproductive teams. Maybe they produced endless discussions or documentations instead of software, maybe they produced thousands of bugs instead the essential features, maybe they produced accusations and blame instead of working together toward a common goal, or maybe they didn’t produce much of anything because they weren’t motivated or didn’t know what they were supposed to build. Productivity in a software team is the team’s ability to produce quality, working software, but the concept is ubiquitous throughout all industries.

This session will address how everyone from the CEO to an entry-level developer can impact the productivity of their organization and the success of their software projects. We’ll look at how techniques from agile and scrum can help improve productivity of teams as well as how individuals, teams, and organizations can each learn productivity lessons from GTD and other non-software disciplines.

Continuous testing promotes the idea that the best way to build better software is by getting feedback early and often. Using continuous testing you get instant feedback on the status of your tests right in your IDE. The earlier you can fix a bug, the less it costs, so why not just fix it right when you create it. The practice of continuous testing blurs the line between syntactic correctness and semantic correctness and helps you build quality code with confidence.

This session will introduce the concept of continuous testing and give examples of continuous testing in Java and .NET.

How many username and password combinations do you have to remember. Stop creating applications with their own authentication database. Stop making your users register for yet another account.

This session will give an introduction to OpenID, how it works, and the options that exist for creating an OpenID implementation. It will conclude with a demo of how to quickly include OpenID in a ASP.NET application that runs in medium trust.

So you’re writing your next application in ASP.NET MVC, why should you give up the elegance of ActiveRecord just because you’re not using Ruby on Rails?

This session will introduce the ActiveRecord pattern and take you through the construction of a web application using Castle ActiveRecord.