Gemba Labs

Fair warning, this is one of those posts that may or may not be useful to many of you out there, but I wanted to document this somewhere ’cause there’s a good chance I’ll need to do it again in the near future. I’m wrapping up a mobile application that needed to communicate with a [...]

I’m not a fan of seeing regions in my code and, by default, ReSharper is configured to group members (methods, interface implementations, etc) with regions when running the Code Cleanup utility. I’ve turned this off a couple of times but it usually takes some poking around until I remember what to do again. From within [...]

I just finished reading Brownfield Application Development in .Net by Kyle Baley and Donald Belcham and thought I’d put together a quick review some of the strengths and weaknesses the book has to offer. It’s broken up into two sections with the first half of the book describing how to create a healthy ecosystem for [...]

The command pattern is another one of those patterns that we all (whether we realize it or not) see almost every day. It’s commonly used in UI development but it’s a pattern that can be applied in many situations. In rails, ActiveRecord migrations are a perfect example of a command implementation, including “up” and “down” [...]

Continuing our exploration of design patterns in Ruby and C#, we’re going to dive into the Iterator pattern. Like most design patterns, if you google (or bing) for an example you will run into several different implementations because there are many ways to iterate a collection of objects. In it’s classic (well, classing in the [...]

In the last post of the series, we took a look at the Observer pattern. This time we’re going to explore the Composite pattern. The Composite pattern gives us the ability to take a complex procedure that may involve many steps and turn it into something that is simple for consumers to use. The classic [...]

Continuing our comparison of design patterns in Ruby and C#, we’re taking a look at the Observer pattern. With this pattern, we have a subject and a list of observers that are interested in knowing when changes occur on the subject. This happens in a push model, the subject maintains the list observers and notifies [...]

In the previous post of this series, we looked at how the Template pattern is implemented in both Ruby and C#. In this post, we’ll take a look at the Strategy pattern…one of my favorites. In it’s classic form, the Strategy pattern consists of a context class and various “strategies” which share a common interface. [...]

Kevin wrote an interesting post in which he expressed his concern for the anemic state of the .Net developer community when compared to that of other communities. I started jotting down a response and saw I was getting carried away so I thought I’d post my thoughts here instead. I heard a comment a couple [...]

Most of my career has been in .Net development and I’m pretty comfortable applying design patterns in C#, but as I’m learning Ruby, I was finding it difficult to figure out how to implement them without creating awkward, hard-to-read code. Recently a local Ruby guru, Nate Klaiber, recommended that I pick up the book Design [...]