Yes, I agree. I think it’s best to give some code examples. This is what
I’d suggest.
- Present a simple problem.
- Show a very natural and simple solution in Ruby.
- Ask the reader, “how would you do this in Perl?”.
The issue is not that Perl “can’t do it”. Rather, it should be an example
where the Perl solution is either difficult, or not as clean as Ruby’s.
Here are two examples. The point of them is not that it’s hard to “do” in
Perl, but rather, that the Ruby solution has a very natural syntax.
Example 1:
···
On Thu, Jun 12, 2003 at 11:19:11AM +0900, Jason Creighton wrote:
If I were you, I would not stress individual advantages, because
somebody will say “Language X can do this too!” Ruby is a great language
because it’s easy to use. It’s easy to write clean OO. There’s a
thousand little conveniences spread throughout the language. It doesn’t
make you write stuff just so the compiler’s happy.
==========
Task: Compute factorials, combinations, permutations and binomial
Code:
Factorial.
class Fixnum
def !
self < 0 and raise "Factorial only defined for non-negative numbers"
self == 0 and return 1
self * (self - 1).!
end
end
Permutations.
def P(n,x)
n.!/(n-x).!
end
Combinations.
def C(n,x)
n.!/( (n-x).! * x._! )
end
Binomail
def Binomial_P(n,p,x)
C(n,x) * px * (1-p)(n-x)
end
Note:
The last three functions are nearly identical to what you’d see
in the textbook. There is nearly zero mapping between math notation
and Ruby’s syntax. THAT is the power of Ruby’s OO. Ruby’s OO allow
me to make Ruby fit whatever my mental model is. Not the other way
around.
Example 2:
Task: Vector algebra in R^n (addition, subtraction, scalar
Code:
class Array
def coerce(other)
return self, other
end
def (n)
n.kind_of?(Numeric) or raise "must multiply by a scalar"
self.map{|e| en}
end
def +(arr)
arr.class == Array or raise "must add/subtract vectors"
arr.length == self.length or raise "lengths don’t match"
sum = []
arr.length.times {|i| sum[i] = self[i] + arr[i]}
sum
end
def -(arr) self + (arr * (-1) ) end
end
Usage:
[1, 2, 3] + [2, 3, 4] #=> [3, 5, 7]
[1, 2, 3] * 2 #=> [2, 4, 6]
2 * [1, 2, 3] #=> [2, 4, 6]
Again, Ruby’s OO lets you adapt the language so you can write things
in correspondence to your mental model.
The Perl code would be something like:
&sum(@vector1, @vector2)
&prod(@vector, $scalar)
And the implementation itself would be more complicated.
I hope that some of this helps.
Daniel Carrera | OpenPGP fingerprint:
Graduate TA, Math Dept | 6643 8C8B 3522 66CB D16C D779 2FDD 7DAC 9AF7 7A88
UMD (301) 405-5137 | http://www.math.umd.edu/~dcarrera/pgp.html