KaizenConf, MVC, and Internal DSLs, OH MY!

First of all, KaizenConf ended up turning out really well. Thank you Scott Bellware, David Laribee, and others involved in its organization. Also, thank you Doc List and the various sponsors who also had a big hand in its success.

Workshop #1: ASP.NET MVC Stuff

Jeremy Miller and I put on a workshop to demonstrate how ASP.NET MVC can be used with heavy opinions to accelerate development and achieve all those ‘-ilities’ you hear us talking about all the time.  Jeremy’s already covered most of the details and posted links to the videos (Part 1 and Part 2), so check there if you want more.

I had promised on several occasions to post as much code as we could that we used/showed in the video, and I was working really hard to make this happen, but unfortunately this puts my employer in an awkward position for a number of reasons. So, please trust me when I say that it’s best for everyone if I don’t just post a bunch of code.

What I am willing to do, however, is to post specific examples of how we use our various “opinions” in our development. I won’t post (much) of the implementation or how we affect those opinions, but the usage is fair game, I think.  Various people have told me that the code in the video is blurry and they want to see more. Can you please mention specific examples and I’ll do my best to get some code up which shows those scenarios? Mention the topic and/or the time in the video where the code is displayed and I’ll get up what I can. Sound good?

I really want to contribute to the community, but I also don’t want to harm my employer who helped make much of this possible. This may not be the end of this discussion, but for now, this is the best thing that can happen. I hope you can understand.

It’s not *much* consolation, but if you’re interested, the PPTX slide deck I used for the presentation can be found on the Pablo googlecode project site.

Workshop #2: Internal DSLs

Later that same day, I gave a solo workshop on building Internal DSLs (originally titled Fluent APIs, but fluent APIs are a subset of what I was talking about, so I renamed it to internal DSLs which more accurately covers the topic).

I personally thought it didn’t go that well (if for no other reason we were all late getting back from lunch).  I broke the first two cardinal rules of presenting workshops: 1.) Don’t be late!  2.) Don’t eat Mexican food before a 3 hour presentation!  But I have been told by various attendees that it wasn’t that bad, so YMMV.

Unfortunately there is no video production of it yet, though most of it *was* recorded. Unfortunately the last bit got cut off due to battery issues, but the last bit was the demo of how to build one.  The source as well as the PPTX deck is, fortunately, available via the Pablo googlecode project.

I’d love to hear your feedback and whether you thought this kind of workshop was useful and whether I should hang onto it and use it later at other events or not!

I still plan on filing out the rest of my Internal DSL blog post series.  My November cleared up a little since an article I was planning on writing for CoDe Magazine got delayed to a future issue *phew*, so hopefully I’ll be able to get onto this.

About Chad Myers

Chad Myers is the Director of Development for Dovetail Software, in Austin, TX, where he leads a premiere software team building complex enterprise software products. Chad is a .NET software developer specializing in enterprise software designs and architectures. He has over 12 years of software development experience and a proven track record of Agile, test-driven project leadership using both Microsoft and open source tools. He is a community leader who speaks at the Austin .NET User's Group, the ADNUG Code Camp, and participates in various development communities and open source projects.
This entry was posted in DSL, Kaizenconf, MVC. Bookmark the permalink. Follow any comments here with the RSS feed for this post.
  • I’d like to see an example of the “typical edit” controller you demonstrated right after the discussion of the Thunderdome Principle around 16:00-17:00 in the video.

  • I’d also like to see the code where you add preprocessing/postprocessing to the Front Controller

  • @Sean Scally:

    1.) We call it the ‘CrudController’ and it exposes New/Create and Edit/Update actions (get/post) which handle most of the minutiae of shuffling data back and forth to/from the view. Our various CRUD-type controllers inherit from it and override a few methods for specific one-off scenarios that are appropriate to each entity being created/edited.

    2.) When a request comes in post-routing and it his our controller’s “Execute” overriden method, we grab an “Invocation” object which handles the INPUT and OUTPUT viewmodel stuff. It’s in here where our pre-/post-processing would happen. Our invocation looks like this:

    - Grab request context data, stuff it into the INPUT viewmodel
    - //TODO: Pre-processing
    - Invoke controller action, capture OUTPUT model
    - //TODO: post-processing
    - Execute ActionResult

  • Thanks Chad.