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.
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.
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
Time permitting, I’ll also share some lessons learned for automated testing of desktop applications.
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
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.
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.
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
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.
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.
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
We’ll come out of the session having built an application
from scratch that uses MEF.
Textual DSLs in Boo
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!