Eric Lee Green wrote:
> Thoughts:
> 
> 4. I like being able to pass around a method in Python. This makes many 
> things much easier.

You can do the same in Ruby. Either use lambda (as in Python) or proc
(Proc.new).

You can also pass methods around in Ruby:

class A
  def b
    p "b"
  end
end


a = A.new

meth_b = a.method(:b)

meth_b.call()   # => "b"

# or convert it to a Proc
meth_b.to_proc

> 10. Reference counting works hand-in-hand with Python's destructors to handle 
> resource cleanups in a real-time manner that's difficult with Ruby (where you 
> can set up destructors of a sort but they only run at garbage collection 
> time, which may be some time later, in the meantime you still have some open 
> files and files on disk hanging around that are not getting cleaned up). 

Use the block paradigm instead. E.g.

DBI.connect do | dbh |
  # do something with dbh
end 

or 

File.open(fileName, "r") do | file |
  # ...
end

Using this there is no need for destructors.

> 13. Python has a nice GUI-based debugger, which makes many things easier. 

16. OOP in Ruby is very clean and much more fun.

17. irb and ri
The autocompletion mode of irb ("irb -r irb/completion") is a great
feature. ri is very useful, too. It can save you alot of time searching
around in the references.

> My preliminary conclusion is that Python is a superior language for large 
> projects. It is virtually impossible to make a difficult-to-read Python 
> program due to its indentation-based syntax, the namespace partitioning makes 

This heavily depends on the programmer who wrote the code. Maybe it looks not that bad 
in Python (due to forced indentation), but the code can be confusing in any language, 
including Ruby. Luckily you can use e.g. Vim to automatically (re-)
indent you code. 
Thereagainst I'd criticise Python's use of method names like _xxx or
__xxx (looks not that nice for me), and all the things that are for me 
not that transparent and are IMHO better and easier solved in Ruby (e.g. mixin, 
use of self as first parameter etc.). But I never worked with these
special features in Python, only had a look on it as non-Pythoneer.

> large projects easier to partition amongst multiple programmers or multiple 
> programming groups, and there is a large number of enterprise-oriented 
> libraries for access to various proprietary and non-proprietary external 
> systems. It is also portable to more architectures than Ruby, which is 
> important for some large multi-platform applications. Python's syntax is also 
> more regular and consistent than Ruby's, which again is important for large 
> multi-programmer projects. 
> 
> Ruby, on the other hand, is a much better scripting language (as vs. 
> general-purpose programming language) than Python. It is much easier to chain 
> pieces together, especially for distributed applications. It also makes a 
> superior language for prototyping Java applications, since many aspects 
> (iterators, rinda, single inheritance only, etc.) are similar to Java. I 
> would not, however, relish attempting to manage 100K+ lines of Ruby code for 
> a project, while Python proved to be quite usable for 100K+ lines of code. 

I'd hold against your last sentence, but I never tried it out.
But maybe 100K lines in Python are just 50K in Ruby ;-)


-- 
Michael Neumann
merlin.zwo InfoDesign GmbH
http://www.merlin-zwo.de