How concise should I make my ruby? [closed] - ruby

Question

As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
In ruby or programming in general is the best practice to be as concise as the language allows or to be concise while still readable? For example:
animals = %w{ cat dog bird }
chosen_animal = rand(animals.length)
random_animal = animals[chosen_animal]
Or
animals = %w{ cat dog bird }
random_animal = animals[rand(animals.length)]
I have a feeling the second one is better code. Is there any benefit of using the first one? Which would you use and why?

Answer 1

as concise as the language allows or to be concise while still readable?
Always, always prefer readability. Conciseness is only useful when it makes your code more readable (i.e., less verbosity and clutter to wade through). It saves you nothing if it obscures the code and serves only to slow development down.
Readability/maintainability only takes a back seat to performance concerns and only when absolutely necessary. This is not often the case in a language like Ruby, more common in a language like C when a bottleneck has been shown to exist that can only be remedied by performing some amount of low level optimizations that may make the code slightly more difficult to comprehend. In this case, add comments that explain the behavior of the code thoroughly.

Answer 2

This is a very broad question with plenty of room for subjective bias.
It is generally accepted that readability is always a good thing. However what is readable varies from person to person.
For example, from your example I would actually prefer the second variant.
There are plenty of people that would say, spread your code out, it helps, but then there are those (myself included) who prefer code that is not so spread out (within limits!) because it allows me to more easily get a feel for the "shape" of the code (structure, loops, conditionals etc) at a distance.
In your example, using one or the other variant does little to affect the readability. But suppose you have a formula like:
r1 = $r*(($objcols-i).to_f+j+k)*3/total_objs
That has a lot more terms in it so it's a lot harder to eyeball. You could pull it apart:
t1 = ($objcols-i).to_f
t2 = t1 + j + k
t3 = $r * t2 * 3
r1 = t3 / total_objs
But does that make it any more readable? In reality this particular formula is just a magic formula to produce a nice random-looking rotation.
You can compromise by spreading it out horizontally:
r1 = $r*( ($objcols-i).to_f+j+k ) * 3 / total_objs
Which at least serves to group the major terms.
But at the end of the day, we are talking about the micro. Whether someone takes 3 seconds or 10 to understand that snippet is not what's important. These are more important:
The reason for the expression must be obvious. IF it's not obvious from the code itself then it needs a comment explaning it.
The code should be easily navigable. This means:
eliminating/reducing repeating code
breaking your program into functions that aren't to small or too large. Again, "too small" and "too large" are subjective terms and there are often exceptions.
Explaining the more complex and high-level structures (e.g. large networks of interacting classes) with plenty of comments.
Lastly, did you know you can do this? (At least in ruby 1.9+):
random_animal = animals.sample
which takes a random element from animals.