On Dec 7, 11:08 pm, Steve Howell <[EMAIL PROTECTED]> wrote: > Python is my favorite programming language. I've used > it as my primary language for about six years now, > including four years of using it full-time in my day > job. Three months ago I decided to take a position > with a team that does a lot of things very well, but > they don't use Python. We use Ruby instead. I'd like > to share my observations about Ruby, because I think > they say important things about Python, which has been > my frame of reference. > > First of all, I actually enjoy programming in Ruby. > Although I'm still fairly early on the learning curve, > I feel like I've achieved basic fluency, and it > generally stays out of the way. > > (A quick disclaimer is that some of the observations I > make about Ruby may simply reflect my ignorance about > the language. I'm still learning it.) > > The thing that I like least about Ruby is its > "require" mechanism. Basically, when you do "require" > in Ruby, it sort of pollutes your namespace. I much > prefer Python's explicitness. > > Some surprising things that I like about Ruby: > > 1) It has the Perlish natural language syntax of > "raise 'foo' if condition." I never missed having > that syntax in Python, but now that I have it in Ruby, > I use it quite often. > > 2) On a general note, Ruby is enough like Python > that it doesn't bend my brain. > > 3) I actually like being able to omit parentheses in > method definitions and method calls. In Ruby you can > express "add(3,5,7)" as both "add(3,5,7)" and "add 3, > 5, 7." The latter syntax is obviously more error > prone, but I don't think I've ever actually gotten bit > by it, and the code appears more clean to me. > > 4) Ruby forces you to explicitly make attributes for > instance variables. At first I found this clumsy, but > I've gotten used to it, and I actually kind of like it > in certain circumstances. > > What I miss about Python: > > 1) I like the fact that Python's syntax for passing > around methods is very natural. Ruby's syntax is much > more clumsy. > > 2) I miss indentation. I get bitten by kEnd in Ruby > all the time. > > 3) I miss Python's maturity. Just to give a small > example, Python's interpreter gives more readable > syntax error messages. > > Those are the things that jump out for me. I'm > curious to hear what other people have learned about > Python after maybe going away from it for a while. > > > ____________________________________________________________________________________ > Be a better friend, newshound, and > know-it-all with Yahoo! Mobile. Try it now. > http://mobile.yahoo.com/;_ylt=Ahu06i62sR8HDtDypao8Wcj9tAcJ
Hello, Standard disclaimer: This response is in the spirit of sharing knowledge and experience, as I take your post to be, not in the spirit of advocacy of any language. All opinions I express are simply that: my opinion. I use both python and ruby quite often. But I came from the other direction, starting with ruby then learning python. Overall, I think they are both great languages, and I believe the choice in whether to use one or the other (or both!) is determined mainly by expedience and preference. I'll try to give my thoughts on your points, which I had as I was learning python a few years ago, along with my current opinions: Ruby: 0.) I found python's concept of namespaces as defined by imported modules (i.e., files) to be strange at first. I used "from foo import *" a lot starting out. The main thing that I had to get my mind around was that in ruby a namespace applies to an object (even "main", i.e., toplevel, is an instance of class Object), and you can "re-open" objects to extend their namespace (or mix in "modules", which in ruby are like a container of unbound methods that you can "include" in another object and thereby bind those methods to that object). So rather than "import" a module with the namespace "string," as in python, in ruby you'd require a file that re-opens class String and extends it. They are two different approaches (and two different ideas of namespace pollution), but once you get your mind around both, they are very easy to use. I almost never use "from foo import *" now in python. 1.) I missed the infix version of conditionals that ruby provides at first, and I would often write things like "if foo: bar" in python if the line was short. Now it just feels more natural to write it on two lines in python most of the time, though in ruby I still use the other notation if the line is short. 2.) I found the same was true. I could basically translate 90% of the ruby idioms directly into python (minor syntax issues aside), and vise versa. 3.) I never have liked omitting parens in ruby method calls (with the exception of methods taking no arguments, but I didn't even do that for a long time), though many/most rubyists do use that style. One problem with it is that it leads to ambiguities, and the parser complains in those cases (e.g., "puts add 1, 2, 3"). However, with predicate methods it does make it read more like a natural language (e.g., "if Jordan.likes? :cookies"). I still parens though. ;) 4.) Yeah, it's hard when learning ruby, especially if coming from languages that distinguish between methods and attributes, to get used to thinking of "a.a" and "a.a=" as method calls and defining accessors for those methods (or using one of the attr_* keywords) in the class body. The equivalent python idiom is something like: class A: __a = "foo" def __init__(self): self.a = A.__a Which roughly translates to this in ruby: class A attr_accessor :a def initialize @a = "foo" end end Python: 1.) I also found python's style of method referencing to be a lot more intuitive than using something like ruby's "m = method('foo'); m.call('bar')" to get a reference to foo() and call it. It's alot cleaner to say "m = foo; m('bar')", imo. But this goes back to the omitting parens thing, which makes it impossible to do it that way in ruby. Though, ruby does allow some interesting things by having it that way, e.g., letting you substitute a Proc object (e.g., a block or lambda) for a method reference transparently. 2.) I also find layout to be a nice feature. And since I've recently been using Haskell, it has only re-inforced that opinion. But when I first started using python, I got bitten by IndentationError quite often. And I kept wanting to type some closing symbol, heh. ;) 3.) I also found (and do find) python's maturity to be nice in many ways. Regards, Jordan -- http://mail.python.org/mailman/listinfo/python-list