Not only that, but most of the time, the expression could simply be written "if myvariable; ...; end", seeing as the vast majority of the time, we only care if the thing we're testing is falsy.
Ruby does give you the tools to be very expressive, indeed almost conversational in your coding style, but it also gives you enough rope to hang yourself.
So this would be a no-no:
unless ($this > $that) {
do_something();
}
He's happy they're used to postfix statements however he says that these should only be used for flow control. For eg. for my $i (@list) {
next unless $i % 2 == 0;
do_something();
}So last example should be:
for my $i (@list) {
next if not $i % 2 == 0;
do_something();
}
Personally I don't follow the bible to the letter :) I do use prefix & postfix unless but only with simple truth conditions like this: unless ($this) { ... }
next unless $this;The idea is lets leave the brainpower for the hard problems, and not require you to use all that brainpower to figure out the plumbing.
resources :people do
resource :avatar
member do
get :republish_deep_links
post :resend
put :accessible_projects, :upload_preference
end
end
That code sets up various URL paths in a Rails app. It maps URLs like /people/george/resend to the proper controller in the MVC framework.In many other languages, you could set up an API like this, but instead of taking a block, the "resources" function would have to accept some sort of nested data structure. That gets you pretty far, but what about when you want to do something that the parser of that data structure didn't expect? Usually you can't.
But in Ruby, code is data and you can do whatever you want in those blocks. You could do this, for example:
resources :people do
resource :avatar
member do
["apple", "orange", "peach"].each do |fruit|
get "eat_" + fruit
end
end
end
That would map /people/george/eat_apple, /people/george/eat_orange, and /people/george/eat_peach.And maybe that's not that impressive to you, but you can inject arbitrary code in there. That's what people mean when they talk about expressiveness.
Examples of this are everywhere in the Ruby world. Check out HAML and assert_select.
APIs + Rigid data structures = Pain and suffering
APIs + Ruby blocks = Flexibility and power
Yes, you're right that my mental model of the 'if' construct will be basically the same in any language, but it's fundamentally less work and less error prone for me to translate ruby than some other language into that model, and the same is true going the other direction
include 'rspec'
your_point.disagree do
the_example.in_ruby = "if myvariable"
me.think do
this_thing(the_example.in_ruby).is(:more_readable)
end.because do
that_thing.expresses(the_example.in_ruby.what_its_doing.minimalist_core)
end
me.could do
using "blub" do
self.say "IfConditionIsTrue(myVariable.booleanValueOfNullStatus())"
end
end.implying do
self.last_statement.is(:crazy_talk)
end
end
your_point.agree do
constructs = languages.map do |language|
in language do
me.mental_models.find_by_name("The If Construct")
end
end
constructs.should be_identical
end.with_caveat do
languages.min do |language|
in language do
me.mental_models.find_all
return me.mental_strain
end
end.should == "Ruby"
endend.should be "Ruby"
display_warning() if problem_condition()
feels much more expressive in some situations than if(problem_condition) display_warning()
The later just emphasizes the primary activity to me - again, in some circumstances. It's something I miss now that I'm not doing Ruby anymore. if (condition) consequence();
You're able to "run" the condition in your head and step into the consequence without loss of pace. But when you put the consequence before the condition, you will have to backtrack. backtrack = true unless consequence.signifies? :block_end
It doesn't seem that much harder to read.To avoid excessive test coverage it would be more pragmatic to do:
backtrack = (consequence.signifies? :block_end) ? false : true
But that's not as easy to read :(
For me, if you write "if (myvariable != null) { }" or "unless(myvariable.nil?) end" doesn't make a difference. In fact, if I were to read it as English "if my variable is not null do" sounds better than "unless my variable is null, question mark?" -- I'm actually puzzled how you would "read" that.
In any case, my argument is that a translation from code -> mental model is more efficient than code -> English -> mental model, in which case expressiveness is only helpful in as much as it helps in parsing the code and not "reading" it in English.