Sometimes when talking about Internal DSLs people criticize the fact that the resulting code well-established breaks code conventions. I just got that kind of comment while showing Hash-QL, my new toy Internal DSL, to some friends. I’m currently studying DSL integration proposals and HashQL is one of the languages I created to try the integration solutions. It’s basic idea is to have some constraints that will be applying against a list of (Ruby’s) Hash objects. So if we want to find all users from Rio de Janeiro above 25 years we’ll do something like this:

user_above_25_years = create_spec{
			[:city == "Rio de Janeiro",
                         :age > 25]
		}

results = @data.find_elements_that :matches => spec

That little snippet has a problem for Rubyists. The Ruby community has a loose set of code conventions but they can be very strict about it. On of those rules says that you must always use a do…end block when you have blocks with more than one line. This makes sense for the Ruby language and I definitely think that code conventions are good (or at least better than no convention at all).

The problem is that the code above isn’t in Ruby. The code above is in HashQL, a language that looks like Ruby (and can be interpreted by a Ruby runtime) only because it was implemented as an Internal DSL. Ruby’s conventions aren’t necessarily applicable here.

I designed HashQL and thought of it as a set of constraints embraced into one thing that I call specification. My original idea was to have even less noise in the constraints grouping, I tried to make the specification above look like this:

user_above_25_years = create_spec{
			:city == "Rio de Janeiro"
                         :age > 25
		}

But couldn’t get this to work without some voodoo like having a class variable at the Symbol class (a global variable in this context) so I sticked to the simpler (to implement) yet noisier version.

Another good example is JMock. Look at the example below:

# allowing (bank).withdraw(Money.ZERO);
will(throwException(new IllegalArgumentException("you cannot withdraw nothing!"); 

This is not Java, it doesn’t follow Java conventions, it is not required to use objects to solve the problems. It is simply a language specific to define mock objects.

By using an Internal DSL you’ll probably mix a lot of host’s and DSL’s code so it is understandable that people get crazy about that convention breakage. While dealing with a DSL, being it internal or external, you have a new language and it has its own style of solving problems and writing code.