UPDATE 1: Schedule is coming tonight. Each workshop is approximately three hours long. We're going with a longer form to get more knowledge transfer, interactivity, etc.

UPDATE 2: Based on space and time constraints, there will be two sessions going on at once. No tracks (we don't do tracks), but I will make an attempt to provide some variety.

Here's the final lineup for the workshops immediately preceding the KaizenConf Open Spaces event. I'm pretty psyched about the line-up. There's some very relevant/edge topics covered by seasoned people chock full of juicy content.

ALT.NET assemble!

#

Advanced NHibernate

Ayende Rahien

Object relational mapping are becoming only more popular, as people developing complex systems find that they need more than the tabular model to work with in their applications. A sophisticated ORM can do a lot more than merely get the data out of the database in object form, it can be a valuable asset in simplifying development and making things possible. In this session, you will see how you can utilize an ORM in nontraditional ways to get an additional, better, approach to solving complex issues.

Some of those ways include business rules, localization, state transitions, inversion of control, etc. All done via the ORM layer, and all can be used to drasticly simplify the complexity of the given scenarios.

Presentation Patterns:  Going beyond MVP and Presentation Model

Jeremy D. Miller and Glenn Block

Our desktop applications are becoming more complicated every year, and just slamming all the behavior into the code behind isn't cutting it any more.  You know about Model View Presenter and Presentation Model for individual screens, but what about the application as a whole?  How do you govern screen activation?  What about communicating across screens?  Extensibility?  In this session I'll present some patterns and strategies for handling complex behavior in stateful clients.  We'll examine some possible approaches for using IoC tools to wire together a composite application.  I'll also present on the screen activation lifecycle, state management throughout the application, and coordinating events over an application.  Taking another tact, I'd like to examine the MicroController pattern combined with language oriented programming as a way to wring out more productivity in our development efforts.

Time permitting, I'll also share some lessons learned for automated testing of desktop applications.

Fluent APIs with C# 3

Chad Myers

You may not know it, but you're likely already using internal DSLs in C#: The Linq IEnumerable extension methods (Select(), Where(), ToArray(), etc), the NHibernate ICriteria API, Rhino Mocks, StructureMap, Windsor, Moq, Ninject, and many others all have internal DSL syntaxes. Whether it be for configuration, programmatic assembly of an object graph, or a myriad of other purposes, an internal DSL can usually make the process go faster, easier to test, and easier to consume by the API consumer.

In this workshop, we'll go through the process of creating a basic internal DSL. We'll then go deeper into more advanced variations and themes of internal DSLs, learn about tricks and pitfalls, and end up with an advanced internal DSL.  We'll learn about method chaining, the builder pattern, function sequences, and many other internal DSL patterns and related concepts.

Using and Abusing ASP.NET MVC for Fun and Profit

Jeremy D. Miller & Chad Myers

After deciding to go with ASP.NET MVC Preview 2, we quickly ran into a few design/testability problems and some missing functionality we needed (it's a preview, after all). Still agreeing that ASP.NET MVC was good and still worth pursuing, we decided to begin filling in some of the gaps and trying to avoid some of the testability problems by creating our own extensions and overriding certain behavior.  Jeremy has come up with some great concepts during this process that we'd like to share with the community.

During this workshop, we'll go through the various additions and derivations we've made in our ASP.NET MVC-based application and how they've helped us create a very adaptable, reusable, and testable web application infrastructure.  The goal is to discuss and contribute ideas to the community, suffer critical feedback, and hopefully increase interest in MVC-based design and testability in a web environment.

Introduction to Lua

Marcus Irven

Lua is a powerful, fast, light-weight, open source, scripting language.  Though Lua can be used for standalone applications a lot of its power lies in how can easily it can be used to extend programs written in other languages.

In this workshop you will get a thorough introduction into the Lua language. After covering the basics we will dive into code and explore the interesting and unique features of Lua. You will also get an introduction on how Lua can be used to extend your applications.

Functional Programming – Is it a game changer?

Matt Podwysocki

We hear a lot about functional programming lately, and many wonder the reasons.  We’ll dig into the philosophy of functional programming, how you can apply it, and what uses it has.  Immutable by default, recursion over mutation and functional composition over inheritance are some of the mind shifts required for this technique.  As we run into Moore’s law changing, we need to be aware of how to realize the full potential of our applications when it comes to asynchronous and concurrent behavior.

Learn how functional programming can help solve some of these problems that we have not only today, but in the years upcoming.  Using languages such as C#, and F#, we can apply these functional techniques today to help make your code more concise.  But, with any paradigm shift, there are traps.  Learn of some of the pitfalls you may fall into and how to avoid them.

Pull, Don’t Push: Lean Systems and Kanban

Dave Laribee

Full description forthcoming. I will say this will be aimed at getting you up and running with an iteration-less pull system or "Kanban." We'll cover some of the principles of Lean Software Development, queue and buffer patterns, and metrics/reporting.

Driving Toward the Goal: Standard Work in Software Development

Jef Newsom

Kent Beck titled his first book on XP "Extreme Programming: Embrace Change." Yet so many organizations and individuals that adopt agile software development practices only attempt to embrace the ongoing change of requirements, not the ongoing change of themselves and their processes. Because of this, so many teams who approach agile software adoption either plateau or backslide into a rebranded status quo. To truly become agile--to truly embrace change--we must focus on constantly improving our people, our products, and our processes.

To determine whether we are improving, we need both an understanding of where we are and to where we want to head. Taiichi Ohno is quoted to have said, "Where there is no standard there can be no kaizen." This notion of "standard work" is key to how the production workers in the Toyota Production System continuously improve the repetitive tasks of manufacturing. And this standard work is not a static "best practice" that we adopt to magically reach nirvana. It is a detailed description of how we currently know to best perform the repetitive tasks, along with examples of both desired outcomes and common defects. We will explore two common "Best Practices" for agile development: TDD/BDD and User Stories. We'll define our standard work, execute it, decide what works and what needs improving, and determine how we'll take action. We'll look for challenges, undesirable effects that are introduced, and we'll think logically about how we can remove them, experiment, and improve our standard.

By the end of this workshop, you will have shared and learned how others in the workshop are best applying practices like user stories and TDD. You will have shared what you struggle with and learned what others struggle with in applying the practices. You will "stop the line," come up with experiments for improving the approaches, try them out, establish a new standard, and continue improving. We'll explore common questions such as: how to identify the right user stories; how best to split user stories and still deliver value; how and where to get started when doing TDD. And we'll explore powerful tools such as: standard work; "stop the line" issue resolution’ TOC's thinking processes

Bring a laptop and your intuition.

All About MEF (the Managed Extensibility Framework)

Glenn Block

Today, it is difficult for applications and frameworks to meet an open-ended set of needs. Building in extensibility allows third-party customization, however there are many challenges in doing so. The application developer is often faced with creating an extensibility mechanism from scratch. This forces the extender to learn a new extensibility model for each application he extends.  The design of the extensibility APIs directly impacts the ability of the extender to do what he wants. The Managed Extensibility Framework (MEF) is a new extensibility model in the .NET framework that addresses many of these problems. It provides as simple declarative model for application developers and extenders. The model itself can be enhanced to support your own semantics. It focuses on discoverability and composition, drawing from lessons learned from the DI (Dependency Injection) community although it is not a traditional DI container.

In this workshop we’ll start with the basics of what MEF is and how you use it. Then we’ll peel back the covers and go deeper into more advanced usages of MEF. Along the way we’ll also look at how MEF compares to DI/IoC containers, and how it fares with TDD and other agile practices.

We’ll come out of the session having built an application from scratch that uses MEF.

Textual DSLs in Boo

Ayende Rahien

Domain Specific Language is not just the DSL SDK from Microsoft. A DSL can make working with the domain much easier, since you are capable of leveraging the domain concepts directly. The other alternative to a DSL is an XML file, and we all know how well declarative model can work when you need imperative concepts, just consider NAnt for a minute and you will see the issue. Usually, writing a DSL in .NET would be a complex issue, requiring writing a parser, interpreter, etc. Boo already handles all of that, and its open architecture means that it is very easy to extend it to express the concepts of the domain. This talk will show you how to build DSLs in Boo and how to utilize this power in your applications.

DDD Chalk Talk

Dave Laribee and Greg Young

Full description forthcoming. Greg *might* make it, still up in the air. This will be a looser and more interactive workshop for all skill levels, but will focus on techniques for implementing rich domain models for .NET. Audience participation is highly encouraged!