Jon Israelson: Ruby

Wed, 18 Feb 2004 22:03:50 GMT

Why's Poignant Guide. A few months back, why the lucky stiff offered up a great warranty. Now he’s at it again, tis time giving us the first glimpse of what looks like a pretty unique approach to learning a computer language, in this case Ruby. It’s one of those sites that’s hard to stop reading: I hope we can convince him to produce a print version for the Pragmatic Bookshelf. [PragDave]

Fri, 13 Feb 2004 22:31:14 GMT

Martin Fowler on Domain Specific Languages. Martin Fowler on DSLs...

I've always used the analogy of creating a DSL to help think about building up a design - developing classes and methods with an eye to making them be a DSL. As much as possible I do this within the language I'm using, but if I can't I'm very ready to switch to code generation. At ThoughtWorks we've used code generation and similar techniques widely on our larger systems. The point at which I pull the separate language DSL lever is clearly different between languages. I never really felt the need in Smalltalk to use a separate language, while it's quite common in C++/Java/C#. [Lambda the Ultimate]

Fri, 13 Feb 2004 22:29:27 GMT

Udell: Programs that write programs. Worth a look.

Jon Bentley in Bumper-Sticker Computer Science quotes Dick Sites as saying I'd rather write programs to write programs than write programs.

For some reason I remembered this quote as saying I'd rather write programs to write programs to write programs than write programs to write programs.

But maybe that's just me...

[Lambda the Ultimate]

Wed, 19 Nov 2003 20:18:12 GMT

artima.com has posted the second in a series of interviews with Matz, the creator of Ruby, titled Dynamic Productivity with Ruby.

Sat, 18 Oct 2003 00:23:07 GMT

The Philosophy of Ruby. Yukihiro Matsumoto, the creator of the Ruby programming language, talks with Bill Venners about Ruby's design philosophy, including design imperfection, the danger of orthogonality, and the importance of the human in computer endeavors.

Rather than discussing Ruby features in particular, Yukihiro Matsumoto explains the principles that guided him in the design of Ruby. Interestingly OO is never mentioned (perhaps it's taken for granted).

An interesting quote:

Yukihiro Matsumoto: Language designers want to design the perfect language. They want to be able to say, "My language is perfect. It can do everything." But it's just plain impossible to design a perfect language, because there are two ways to look at a language. One way is by looking at what can be done with that language. The other is by looking at how we feel using that language-how we feel while programming.

Because of the Turing completeness theory, everything one Turing-complete language can do can theoretically be done by another Turing-complete language, but at a different cost. ...

Instead of emphasizing the what, I want to emphasize the how part: how we feel while programming. That's Ruby's main difference from other language designs. I emphasize the feeling, in particular, how I feel using Ruby. I didn't work hard to make Ruby perfect for everyone, because you feel differently from me. No language can be perfect for everyone. I tried to make Ruby perfect for me, but maybe it's not perfect for you. The perfect language for Guido van Rossum is probably Python.

and also:

Yukihiro Matsumoto: Ruby inherited the Perl philosophy of having more than one way to do the same thing. I inherited that philosophy from Larry Wall, who is my hero actually. [Lambda the Ultimate]

I'm a big fan of Ruby and this provides a view of the language from the perspective of its designer.

Tue, 05 Aug 2003 03:28:32 GMT

Ruby 1.8.0 is out! Sources are ready for download as is the list of changes since 1.6.x. Binaries, including the Prag Programmer's Windows installer, should be available soon.

Thu, 31 Jul 2003 03:41:50 GMT

There were several good discussions on c.l.r today. First up is this one on Message-Object-Oriented compared to Function-Object-Oriented. I was reading the originating article just the other day. Anyway, the guy, James, that started the thread on c.l.r came up with a way to make Ruby syntax more like MOO. It's ugly, but it shows how easy it is to manipulate Ruby. Here's the magic:

I set about finding a way to do it in Ruby, and came up with an addition to the Symbol class. I wasn't sure if I wanted to have a full-blown Message class; I liked the idea that one could just type the message to send without having to go create a special object for it. The Symbol syntax makes this very natural

class Symbol
   def >>( *args )
     ary = []
     arglist = (block_given? ? yield : nil )
     args.each{ |obj|
       begin
        ary << dispatch( obj, arglist )
       rescue Exception
        ary << $!.clone
       end
     }
     ary
   end

   def dispatch( obj, arglist )
     return obj.send(self.to_s, *arglist) if arglist && (arglist.size>0)
     obj.send( self.to_s )
   end
end

This allows expressions like:

:some_message.>> obj
:some_message.>>( obj1, obj2 )
:some_message.>>( obj1, obj2 ){ [ arg1, arg2, arg3] }

Any message string, instantiated as a Symbol, can be dispatched to a list of objects, along with a set of message arguments. The results come back as an array.

The second thread is about implementing Ruby in Ruby. This is the same idea demonstrated by creating a Lisp interpreter in Lisp. Dan Sugalski (of Parrot fame) started an interesting thread. See this for more along those lines.