Hacker News Reader

Comment by lr4444lr | Hacker News Reader

Not denying Ruby is good, but other than process forking, why should I prefer it to Python?

Personally, I find Ruby's syntax more natural, (I'm going to be heavily biased though, having written Ruby for 10+ years). But for example, let's say I wanted to make a hash (dict) of files, keyed by their size (for some unknown reason), in Ruby it would look like:

  Pathname.glob('*').filter { |f| f.file? }.each_with_object({}) { |f, h| h[f.size] = f }

Whereas the equivalent Python would be:

  result = {}
  for file_path in glob.glob('*'):
    if os.path.isfile(file_path):
      result[os.path.getsize(file_path)] = file_path

Or capitalizing a string in Ruby:

  string.split(' ').map(&:capitalize).join(' ')

And in Python:

  words = string.split(' ')
  capitalized_words = [word.capitalize() for word in words]
  result = ' '.join(capitalized_words)

Python seems to be more convoluted and verbose to me, and requires more explicit variable declarations too. With the Ruby you can literally read left to right and know what it does, but with the Python, I find I have to jump about a bit to grok what's going on. But maybe that's just my lack of Python experience showing.

You can capitalize a string in Python using functional style

  ' '.join(map(str.capitalize, string.split(' ')))

which is similar to the example in Ruby, except the operations are written in reverse order.

    result = {os.path.getsize(f): f for f in os.listdir() if os.path.isfile(f)}

    result = ' '.join(word.capitalize() for word in string.split(' '))
    result = ' '.join(map(str.capitalize, string.split(' ')))
    result = string.title()

  from string import capwords 
  result = capwords(string)

This does the split/capitalize/join dance, all in one.

The file example you gave could also be turned into a dict comprehension if desired. I’m on mobile, but I think this would work.

  result = { f:os.path.getsize(f) for f in glob.glob(“*”) if os.path.isfile(f) }

Not using white space as a delimiter

Ruby is surprisingly picky with white space

Can you give an example? I can't think of a single situation where whitespace matters in Ruby (unless of course you forget to put a space between two commands or something silly).

if foo is a method then

`foo + bar` and `foo+bar` are `foo()+bar`, but `foo +bar` is `foo(+bar)`

ternary ? : also has some interesting whitespace dependent mixups with symbols, but I cannot remember what. I think that parser has many gotchas like that, but they are really really rare to bite you, because ruby's magic follows human intuition as much as possible.

still less annoying than Python's semantic whitespace

It's not really a problem in practice (and I love Ruby), but it's still wild to me that they made the parser do this:

    $ irb
    irb(main):001:0> def foo(x=70) = x
    => :foo
    irb(main):002:0> i = 2
    => 2
    irb(main):003:0> foo / 5/i
    => 7
    irb(main):004:0> foo /5/i
    => /5/i

Yea but it’s still not a delimiter

It’s just preference at that point IMO, and I’d base it off “what language are the rest of the scripts using?”.

For 99% of use cases (especially when writing shell scripts) it doesn't matter, just pick the one you know better. Both are nicer than Bash though. :)

Reply on news.ycombinator.com