chromatic wrote about a Ruby programmer who doesn't quite seem to "get" domain specific languages and uses his misconception to bash Perl. Aristotle points out that this programmer still doesn't get it.
Instead, I'd recommend that people read about DSLs and try to understand what that article is really talking about.
It's not talking about programming in such a way that you have meaningful subroutine or method names. As a counter-example, here's a snippet of a DSL I implemented for an implementation-agnostic query langauge:
name => 'foo',
l_name => 'something',
OR( age => GT 3 ),
one__type => LIKE 'email',
fav_number => GE 42
Now that looks an awfully lot like Perl code and, in fact, it's valid Perl. I implemented that in Perl and it worked, but you could also send it as a string and it still would work. However, as a string, I did not eval the string. Instead, the Perl code was comprised of subroutines which, when invoked, would return tokens. The string, when lexed, would return identical tokens. Then the token stream, whether from Perl or from a string, would be driven through the same parser and produce a query object which could then query anything you needed to, whether it be a database, CVS files, XML docs, whatever.
So our little DSL could be used to query anything we needed. We needed a DSL to ensure that we had implementation-agnostic searches. Got it? It was not eval'ing any code (there were block evals for catching exceptions, but that's not the same thing as a string eval, something Cosine is mistakenly using).
A DSL is a mini-language for clearly representing and working in a particular problem domain. In the example above, the mini-language also happens to be valid code in the primary programming language I'm writing, but that's almost a coincidence in this case. Serious DSLs generally require some method of transforming the strings into actual code. I used a proper lexer/parser (Parse::RecDescent wouldn't work because I need to decouple the lexing and parsing), it ran quickly, was safe to use, and allowed one to easily write queries without caring about what you were querying.