Presenting the KaizenConf Workshops

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

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.


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


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.


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

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!

This entry was posted in ALT.NET, Community, conferences, housekeeping. Bookmark the permalink. Follow any comments here with the RSS feed for this post.

19 Responses to Presenting the KaizenConf Workshops

  1. Dave,
    The schedule hasn’t been posted yet.

  2. Has the schedule been posted for the workshops times yet?

  3. Krzysztof,

    About a month ago we began the discussion about doing a Continuous Improvement conference in Europe.

    We’re looking at Edinburgh, Scotland, possibly late in the spring of next year.

  4. We are WAY over-booked on space for both the workshops and the open space. I personally know about a third of the people attending. The rest of the participant body is made up of people I don’t know, and who submitted invitation requests.

    We have a limited headcount, limited budget, a free conference, and a goal to produce a conference report written by the participants as a working conference. This means that we’re choosing people to come to Austin AND WORK.

    Open spaces are inherently invitation-only, even though the format can be tweaked – and even perverted if organizers aren’t diligent. For the Continuous Improvement conference I wanted to bring in new people whom we weren’t already aware of and so we opened the invitation process up to the public.

    This conference is categorically open to the public, but that doesn’t mean that any particular individuals has a built-in right or entitlement to be part of the conference – especially a working conference like this one where participants are part of a work team and building the participant body is a matter of recruiting, selection, and yes even declination.

  5. Dave Laribee says:

    @All – Openness is hard. We do our best. This is a prototype event. If it goes well, we’ll do more of these in varied locations.

    We have very tight constraints on money and space. I can only hope people understand this.

    VIDEO: I will try to capture as much video as humanly possible and publish it to the world. I’ll encourage the workshop leaders to do the same!

    @Krzysztof – Set something up. Would be happy to work with you on that and come out if I can.

  6. Why don’t you do these conferences in europe? 😐

  7. Alper says:

    Even though I requested an invitation fairly early, my request for invitation was denied. I thought this was because the headcount was exceeded. After reading Brian’s comment, I’m not so sure. This makes me question the conference’s openness to public like Sean.

  8. @Sean

    From what I remember hearing, invitations were given based on Scott Bellware’s impression of what an individual would bring to the conference. Not exactly what I would call “open to the public.”

    But, hey, it’s his conference, I guess. He has the right do whatever he wants with it.

  9. Sean Scally says:


    I’m not sure I understand. I went to the site, checked the boxes saying I wanted to attend the workshops and open spaces event, and received an email telling me that my “request for an invitation was declined”.

    How is an invitation-only event open to the public?

  10. Alper says:

    It’s unfortunate that it got filled so quickly.
    I was unable to register and put on a waiting list.
    +1 for recording the sessions.

  11. @Sean,

    The workshops are open, it’s been announced for quite awhile, and they’re free to attend for anyone. I don’t recall a restriction about being a card-carrying ALT.NET blogger as a litmus test to attend.

  12. Sean Scally says:

    Sounds good. Too bad it’s not open to the public… alot of people outside of the ALTNET blogosphere could have benefitted.

  13. Dave Laribee says:

    @Tim – Sessions are three hours; we want to allow for more than the typical 1:15hr presentation, more Q&A, interactivity, games, you know – workshop stuff. I’m slotting stuff today and will post a schedule tonight.

  14. Tim Barcz says:


    Any ideas how long the sessions are or more importantly how many are going on at once? I’m curious how much picking we’ll have to do between workshops/tracks or if there is a single track over two days that allows attendees to go to all.

    Looking forward to next week.


  15. RYan Kelley says:

    Looks like some good stuff, can’t wait!

  16. Dave,
    We still need the actual schedule for them :-)

  17. Yet another vote for recordings from these sessions, will it be possible? It would be fantastic to watch them.

  18. Gabriel Schenker says:

    You guys do a fantastic job. I’m really looking forward to the two days of work shops and of course the open space afterwards. thanks for your effort!

  19. Hi Dave,

    Any chance of recording the sessions for us who are overseas? 😉


Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>