Summary
In both Ruby and DITA, domain specific languages make elegance possible. More importantly, each is producing an ecosystem of domain specific languages (aka "power tools") that is making it more powerful as time goes on.

I just blogged about something that Ruby and DITA have in common--Domain Specific Languages (DSLs), and the productivity ecosystem they create. Here is an excerpt of the stuff that is pertinent to Ruby....

The term domain-specific is unfortunately inaccurate in one important respect: It brings to mind highly specific problems, like those encountered in a shoe store, for example. In that sense, "domain-specific" tends to make you think of highly targeted IT applications--all very important, but unless you have such an application in mind, and can think of a language you might want, the concept of a DSL tends to remain an interesting abstraction with little practical value.

But there is a middle ground of DSLs that is highly general. That middle ground consists of general purpose languages that help you tackle a specific problem you face every day in the same way that others do, even though they are working in different areas. In Ruby, such languages help developers perform programming tasks. In DITA, they help writers provide information artifacts that technology users need.

The languages that live in that that middle ground might be called "general purpose domain specific languages", but that's pretty much a contradiction in terms. And it's a mouthful. So maybe we would be better served by calling them something else, like "empowerment languages" (ELs) or better, "PowerTools". Because what they do, first and foremost, is give you powerful tools you can use to help you build whatever it is you're constructing.

Ruby

In Ruby Rocks!, I wrote about the intrinsic aspects of the language that makes development a pleasure. But the ecosystem of DSLs that is growing up around Ruby is perhaps it's greatest long-term asset.

Interestingly, the categorized list of Ruby gems at RubyForge shows some 800 projects devoted to software development. Some of the most powerful are DSL power tools. On the other hand, there are DSLs that aren't Ruby gems at all. Here is a list of "world-changing" DSLs:

• Rake is a fantastic build language that provides a lot of power with simple, clean syntax. For more on Rake, see Rake Rocks.
  
  
• Ruby on Rails is a well-known DSL that is designed for building web applications.
  
  
• RSpec is a tool for writing unit tests that are both readable and executable. Because they specify behavior in a readable way, they are more like specifications--hence the name: R(uby)Spec. Of course, as one blogger rightly pointed out, an RSpec files isn't really a specification, because it doesn't declare abstractions like "returns n**2 for all integers greater than zero". [I've lost that link! If anyone finds, please send it to me so II can point to it. --thanks, eric] What Rspec does in reality is to produce a "specification by example" that can be executed as a series of tests. But those comments do lead to an interesting extension to consider for RSpec:
  
  
• The capacity to randomly generate one of two specific elements that match a pattern like "an integer greater than zero", or "an integer less than zero", so that different aspects of the abstraction can be tested in a way that tends to ensure the abstraction is implemented, rather than a case statement that satisfies the tests, and only the tests. (Of course, the test harness could only generate random input values. Generated output values would require another implementation of the algorithm, which would itself be subject to testing--a never-ending loop. But the problem can be finessed with data hiding. If some external entity like the quality control group creates a table of test values, and the developer doesn't know which values will be used, then a general implementation is required to ensure success.)
  
  
• Martin Fowler's XSL in Ruby is described in what will probably turn out to be a seminal paper: Moving Away From XSLT. It combines the declarative power of XSL with the capacity for loops, conditionals, and functional coding whenever you need it.
  
  
• OptiFlag is a DSL for processing command-line options.
  

Here are a couple of Ruby gems that sound interesting. I don't know much about them, as yet, but I'd love to find the time to explore them further:

• Aquarium adds aspects to the Ruby language.
• Dhaka is a parser generator.

Resources

DSLs

• Introduction to DSLs, from an upcoming book by Martin Fowler
  http://martinfowler.com/dslwip/Intro.html
  
  
• Video of a presentation on the subject by Martin Fowler
  http://www.infoq.com/presentations/domain-specific-languages

• Fowler's articles on Language Workbench programming:
• Language Workbenches: The Killer App
  http://martinfowler.com/articles/languageWorkbench.html
• Language Workbenches and Model Driven Architecture
  http://martinfowler.com/articles/mdaLanguageWorkbench.html
• A Language Workbench in Action: MPS
  http://martinfowler.com/articles/mpsAgree.html
  

Ruby 

• Ruby Rocks!
  http://www.treelight.com/software/ruby/RubyRocks.html
  

• The categorized list of Ruby gems at RubyForge:
  http://rubyforge.org/softwaremap/trove_list.php

• Rake Rocks!
  http://www.treelight.com/software/ruby/RakeRocks.html
  
  
• Readable intro to RSpec 1.1.2
  http://rspec.info/
  
  
• RSpec cheat sheet:
  http://blog.daveastels.com/files/QuickRef.pdf
  
  
• Martin Fowler's writeup on XSL in Ruby: Moving Away From XSLT
  http://martinfowler.com/bliki/MovingAwayFromXslt.html
  

• Acquarium: Aspects for Ruby:
  http://rubyforge.org/projects/aquarium/

• Dhaka parser generator:
  http://rubyforge.org/projects/dhaka/

Talk Back!

Have an opinion? Readers have already posted 29 comments about this weblog entry. Why not add yours?

RSS Feed

If you'd like to be notified whenever Eric Armstrong adds a new entry to his weblog, subscribe to his RSS feed.

Digg | del.icio.us | Reddit

About the Blogger

Eric Armstrong has been programming and writing professionally since before there were personal computers. His production experience includes artificial intelligence (AI) programs, system libraries, real-time programs, and business applications in a variety of languages. He works as a writer and software consultant in the San Francisco Bay Area. He wrote The JBuilder2 Bible and authored the Java/XML programming tutorial available at http://java.sun.com. Eric is also involved in efforts to design knowledge-based collaboration systems.