Otaku, Cedric's weblog

If you really need the method overloading you can try this package http://mephle.org/StrongTyping/. Ruby is very expressive language where you can emulate a lot of things. Regarding orthogonality you are absolutelly correct, that why it is so pleasure to program in ruby.

Cedric, you might like Groovy then (shameless plug)...

http://groovy.codehaus.org/

Groovy is a python/ruby style language designed for the JVM. So it compiles down to normal Java bytecode & Java classes, yet has much of the power of Ruby (closures, lists/maps syntax, generators, dynamic typing etc).

The nice thing is that both inside the Groovy language and outsite (in the JVM) there is no difference between Groovy or normal Java objects - i.e. groovy objects can use Java objects and vice versa.

Incidentally Groovy fixes all of your 3 complaints.

* no Perlyness
* uses {} for blocks
* method overloading (and operator overloading)

The 'end' syntax was the one thing which looked so ugly and BASIC to me that it kept me off Ruby.

I think Ruby can use { } instead of END

"The 'end' syntax was the one thing which looked so ugly and BASIC to me that it kept me off Ruby."

I had the same initial reaction, but I kept hearing good things about it, so I bought the PickAxe book and dug in. I was soon won over, so much so I that I now manage http://www.rubyxml.com and http://www.ruby-doc.org.

I tend to use { ... }, and only use begin/end for blocks and exceptions, so the sematic difference is more clear. And I rarely need to use any of the Perlisms.

"The Perl heritage" was my mistake. Their use will be removed or at
least warned in the future, parhaps with exceptions of regular expression
submatches, e.g. $1, $2, etc.

"The meaningful indenting" is plain wrong for a language like Ruby,
where expressions and statements are interchangeable. See the lambda
problem in Python. Guido decided to remove it in the future. But I
won't give up lambda nor value giving blocks. Using the word "end" is rather a matter of taste.

Finally, I am not against "method overloading", but it very easily leads to optional static typing in the language, which changes the language
very drastically, since you need to specify "type" to overload
arguments. Without well-thought design, it can "destroy" the language
and its culture. I have not yet got that well-thought design of
method overloading.

As a newcomer to ruby, with a perl/c/java background, I am astonoshed that simple 'argument count' overloading does not work. Surely most people would expect this to work:
class Test
def initialize
@v1='unknown'
@v2='unknown'
end
def initialize(v1)
@v1=v1
@v2='dunno'
end
end
al.

IMHO multiple dispatch is better than method overloading. A method is implemented multiple times like in overloading. At the time of the method call the types of the arguments determine which method is invoked. Something like a big switch generated by the language and containing forward calls to the different methods. But I cannot see how it could be implemented in Java nor in Ruby. They only offer single dispatch on the invocant (the object before the dot of the method call).

i also dislike the use of 'end' (just about the only think i *don't* like in ruby). so, since everybody is saying that this is a matter of taste, does that mean that this will work:

class Hello
{
attr_reader :msg
def initialize
{
@msg = "Hello, World"
}
}
h = Hello.new
puts h.msg
print "Press RETURN"
$stdin.gets

Or what about this:

def fib(n)
{
if (n<2)
{
n
}
else
{
fib(n-2)+fib(n-1)
}
}
print(fib(20), "\n");

in other words, i'm more comfortable with {} coming from C,C++, & C# so what are the precise syntax rules for substituting {} for 'end'? is there anything wrong with how i structured my code above? I keep getting syntax errors & "odd number list for Hash" errors, & i'm pretty sure it has something to do with my syntax, since both of these work in their original form (using 'end').

Thanks!

I personally love the "end" syntax for blocks. Often I find myself liking the usage of plain words instead of so many symbols while programming in Ruby. I think the {}'s show Java and C's formality while "end" expresses Ruby's easy, comfortable appeal.

When I moved from C++ to pascal I sooned learned to appreciate 'end' since it was in keeping with pascal's neatness. And wow did that neatness make a big difference in productivity.

Well, ruby seems to have that virtue also, and it just seems right. I still avoid curly braces (except for one liners) in my ruby code, but I like the tip above about using 'end' for exceptions; but I'll do it the other way around.

My only problem with 'end' is readability. Tabbing is not enough to be clear on where blocks begin and end. Brackets can be lined up for easy readability.

But, I love ruby, so I use end.

I also would like to see argument count overloading. That's not so ambiguous, is it?