I've also found Scala has a similar feel to Ruby, which is a bit surprising given Scala's static type system and Ruby's extreme dynamicness.
Here are a few similarities:
* concise syntax (Ruby via dynamic typing, Scala via type inference)
* hybrid OO-functional (Ruby isn't normally described this way, but it has a lot of functional idioms built in, and unlike in Python, they're often considered good style)
* dogmatic wrt the OO part (i.e. every value is an object, unlike Java or C++)
* TIMTOWTDI (should my Scala higher-order function take a function or a lazy value?)
* DSL fetishism
* very flexible and adaptable syntax, which (for both languages) is a two-edged sword - esp. things like Ruby's optional method invocation, and Scala's optional dot
* both allow adding methods to existing classes (Scala fakes this via implicit conversions, but I believe it's idiomatic)
The thing which appeals about Duby is that it uses the underlying Java typesystem, and doesn't have a runtime library. If it ever gets finished, it can be as fast as any Java code, and there's been a lot of effort put into making Java code fast.
Here are a few similarities:
* concise syntax (Ruby via dynamic typing, Scala via type inference)
* hybrid OO-functional (Ruby isn't normally described this way, but it has a lot of functional idioms built in, and unlike in Python, they're often considered good style)
* dogmatic wrt the OO part (i.e. every value is an object, unlike Java or C++)
* TIMTOWTDI (should my Scala higher-order function take a function or a lazy value?)
* DSL fetishism
* very flexible and adaptable syntax, which (for both languages) is a two-edged sword - esp. things like Ruby's optional method invocation, and Scala's optional dot
* both allow adding methods to existing classes (Scala fakes this via implicit conversions, but I believe it's idiomatic)