This post (via this post) provided an obfuscated Ruby program to take care of that for you… thanks!

#!/bin/ruby
# Slightly obfuscated cygwin + windows java wrapper, automate cygpath
 
cpi = ARGV.index("-cp") + 1
cp = ARGV[cpi] if cpi
 
XBCP = "-Xbootclasspath/a:"
 
xbcpi = ARGV.index{|i|i=~/^#{XBCP}.*/}
xbcp = ARGV[xbcpi] if xbcpi
 
if cp or xbcpi
  def convert_paths(paths)
    paths = paths.gsub(':', ';').split(';')
    paths.map{|p|`cygpath -aw #{p}`.strip}.join ';'
  end
  ARGV[cpi] = convert_paths(cp) if cp
  ARGV[xbcpi] = XBCP + convert_paths(xbcp.sub(XBCP, '')) if xbcp
end
 
java = '/cygdrive/c/Program Files/Java/jdk1.6.0_18/bin/java'
cmd = [java].concat ARGV
 
def e(s); "\"#{s.strip.gsub('"','\"')}\""; end
 
exec(cmd.map{|a|e a}.join(' '))

It is interesting that they took the approach to compromise by neither being too aggressive nor to permissive; in other words they wanted to make sure that people would actually use the tool. As such, type inference is strong enough to detect type errors, but permissive enough to allow for the same variable to have a different type of object assigned to it within the flow (dynamic extent) of a single method.

Another nice feature is the addition of a contract system for cases where type inference would not work; the two primary examples being utilization of the built-in classes which are implemented in C or the use of eval. The contracts specify the behavior and the implementation needs to conform to it.

With things like Diamondback Ruby, PLT Scheme Contracts, and Typed Scheme (mentioned in the paper) becoming available; I wonder if the statically vs lately typed language arguments will eventually go away.

(via LtU)

Avi Bryant wondered as such, and seems to have gotten a job out of it in producing Maglev Ruby (it is a video).

Maglev seems to be the combination of a Ruby VM implemented along with a distributed, concurrent object system to support the needs of Ruby on Rails.

I heard Avi speak at OSCON 06, and he seems to be a nice fellow; I’ll be interested to see how this pans out.

Strangely, I haven’t heard Maglev mentioned by anyone I know, perhaps Ruby VMs aren’t interesting.

When [Matz] was first starting out writing Ruby, he was coding the Emacs ruby-mode.el for it at the same time. He expressed some frustration with modes for other languages like Python and Pascal in which the editor could not look at a line of code and figure out where it should be indented to, so he resolved that Ruby as a language should not fall into that particular trap. With that in mind he chose the end keyword as a block delimiter so that it would be easier to write an Emacs mode for.

Pass a message to the integer start index which includes both the inclusive stop index and a single argument function that is to be called with the current index in the iteration. The implementation of this feature, which can be found here, is written nearly as you would imagine, albeit in C. Here is how the code looks when you call this function:

1.upto(3) {|x| printf "#{x}\n"}
1
2
3

With my programmer’s glasses on this, I would say that this syntax feels nice. In fact, it feels nice enough to think about adding a feature like this to Scheme. Here is what I came up with:

(define-syntax from
  (syntax-rules (upto)
    ((from x upto y fn)
     (let ([finish (add1 y)])
       (let loop ([cur x])
         (if (not (= cur finish))
             (begin
               (fn cur)
               (loop (add1 cur)))))))))

Here is how the Ruby sample from above looks in Scheme.

(from 1 upto 3 (λ (x) (printf "~a~n" x)))
1
2
3

What do you think? The two samples really don’t look all that different.

Grow-able languages are truly exciting. If you want to add a feature to the language, you add it.

Programming with grow-able languages takes you from “power-user” to empowered-user!

Which would you rather be?