-
2) It might be because I spend a lot of time with Ruby, but I much prefer `end`s to curly brackets, they're just easier on the eyes, especially when they're going to take up the entire line anyway: a
b
c
d
end
end
end
end
a {
b {
c {
d {
}
}
}
}
Of course, at times I wish Ruby used indentation to declare structure, like Python. -
3) I don't think I've ever had that problem. If I'm calling `person.full_name`, I don't care if that's a variable, or a method joining first_name and last_name. And if I it was a method, ideally I'd have a corresponding `full_name=(str)` method defined too, so `person.full_name = "Joe Bloggs"` would work, and split the string into the first, last, and optional middle names. -
4) Why? Why not? What makes this easier to read? puts "Bankrupt" if balance <= 0.0
Ruby is a lot like the English language; when you're learning it as a second language, you're constantly confused and frustrated by it's weird syntax, but once you get past those initial hurdles, it just clicks. I love Ruby because I never feel like I'm programming in it, it almost feels like pseudo code that's not going to actually execute.Essentially you could get any non-programmer to solve a problem on paper, and turn it into Ruby code which, without too much fuss, describes their process.
# get the customers text file
# each customer is on their own line, w/ their name and age separated by a comma
# group the customers by age
# show me the top 3 most common ages
file = File.open('customers.txt')
customers = []
file.each_line do |line|
name, age = line.split(",")
customers << {:name => name, :age => age.to_i}
end
grouped_ages = customers \
.group_by{ |c| c[:age] } \
.map{ |c| [c[0], c[1].size] } \
.sort_by(&:last) \
.reverse
grouped_ages.first(3).each do |age, size|
puts "#{age} years old: #{size} customers"
end
Four blocks of reasonably clean code (except the 3rd, that could be cleaned up a bit), which implement the four lines of plain english instructions.Uh, you realise that describes any high level language, right? Ruby scores pretty low on the readability scale, about halfway between Perl and Python, but I find it's more familiarity with a particular language that determines how readable people find things.
Here's a quick Python version. The main thing to notice is that while the overall flow/structure is similar, I don't have a lot of { } << \ characters hanging around, and I don't have to chain blocks together since I have list comprehensions.
from collections import defaultdict
customer_file = (line.strip().split(',') for line in file('customers.txt'))
grouped_ages = defaultdict(list)
for name, age in customer_file:
grouped_ages[age].append(name)
age_lengths = sorted( [(len(names), age) for age, names in grouped_ages.items()], reverse=True )
for length, age in age_lengths[:3]:
print "%s years old: %s customers" % (age, length)I'm inclined to agree. I think the following also pretty closely matches the english requirements.
(with-open [rdr (reader "customers.txt")]
(->> (line-seq rdr)
(map #(second (.split % ",")))
(group-by identity)
(map (fn [[age coll]] [age (count coll)]))
(sort-by second (comparator >))
(map first)
(take 3)))I think one of the side effects of learning a Lisp is that you get a bit blasé about using map. Do you find list comprehensions easier than map/filter? Is there a list comprehension equivalent in Lisp, or would you have to write your own?
As for preference, given that map, filter, etc., are lazy, I like the clear visibility of each step working on each element of the sequence.
Clojure has a list comprehension, for, though using it here is more trouble than it's worth since you have to group and sort, both of which require you to step outside the comprehension and work on the whole list; that's why your code has multiple sections.
Instead, I see the example as just a selection/transformation process on sequences of data. Each step in the clojure code takes and returns a sequence of values (the ->> macro weaves them together):
0. a sequence of lines from a file
1. a sequence of age strings
2. a sequence of [age, [ages...]] tuples
3. a sequence of [age, count] tuples
4. a sequence of [age, count] tuples sorted by count desc
5. a sequence of age strings
6. a sequence of up to 3 age strings
Fun detail: The with-open macro is akin to python's with statement, supports arbitrary number of items, is closed in reverse order of their appearance, and didn't require a change to the language to implement ;)Also, I'm pretty sure that writing a macro counts as 'changing the language', although that line's a bit blurred when you're talking about lisps ;) ;)
You brought up list comprehensions, and something about being "blasé about using map". I wanted to show how a different way of modeling the problem yields a different structure to the code (namely, as a chain of transformations on sequences).
One is not better or worse than another. One of the things I enjoyed most about learning clojure was forcing myself to think in these different ways.
Anyway, ataggart didn't write a macro he just used one that's already part of the language. Using a macro does not count as changing the language.
Also, this is a better version in Ruby:
file = File.open('customers.txt')
customers = {}
file.each_line do |line|
name, age = line.split(",")
customers[age.to_i] ||= []
customers[age.to_i] << name
end
grouped = customers.sort_by{|age, names| names.count}.reverse
grouped.first(3).each do |age, customers|
puts "#{age} years old: #{customers.count} customers"
end
…not sure what I was thinking before, it was late.That's likely because you're not used to reading Python. For me, Ruby seems unreadable - you have all these weird << and ||= assignments, {||} blocks, etc. I don't parse those as well, because I don't program much Ruby. I'm sure if I did, it'd make a lot more 'intuitive' sense - ditto for you and Python's list comprehensions.
That said, I do find the more "squiggly" languages (Perl, Ruby, C) to be less readable than the equivalent Scheme or Python, and I suspect that it's because there are fewer weird characters, so it's closer to English.
from itertools import groupby
customer_data = (line.strip().split(',') for line in file('customer.txt'))
grouped_ages = groupby(customer_data, key=itemgetter(1))
print sorted((len(list(g)), k) for k, g in grouped_ages)[-3:] from operator import itemgetter
as well.I would point out, however, that printf is fairly rarely used and that I am not familiar with fincher.org in the context of sites to recommend newbs to learn Ruby from.
Removing the difference between accessing an attribute (variable) and invoking a method is a solid OO principle. You, as a client of the API, should not care how obj.foo is implemented.
It's called the Uniform Access Principle[1] and the languages that don't take advantage of it often suffer from a getter/setter hell.
Hey presto! Now you have the best of both worlds.
I disagree. Code execution is not data access. They are very separate concepts.
Whether you like that or not is immaterial. You are free to avoid that aspect of OOP or the paradigm altogether.
For example,
class flower
property color
property numberOfPetals
method pluckPetal()
method water()
A property defines data about an object, and a method defines something you can 'do' with the object.Could you give some pointers to the OOP principle that blurs the line between these two?
There are languages where UAP is enforced by the syntax (eg. Eiffel, Smalltalk, Ruby) and languages where it's a matter of convention. But even in the latter it's considered a good practice to keep properties private and encapsulate them with accessors. Some even have dedicated features that help with that (auto-properties in C#, properties in Python).
There is absolutely no reason for that, and the grandparent of all things object-oriented (Smalltalk) very strongly disagrees with you: everything is a message, and there are no properties.
> A property defines data about an object, and a method defines something you can 'do' with the object.
A getter method is a property and a method. Properties are irrelevant, access should be uniform, the implementation details of an object (whether a "property" provides direct access to internal data or not) is of no concern to the user of the object.
A property is nothing more than a method whose contract is "give me some data"
However, for me, and the CPU, we treat code execution differently to data access.
1. It's not ugly
2. It's how CPUs work
3. It's how most people think
2. If you want a programming language that maps closely to how CPU's work, Ruby's definitely not for you. Assembly and C are for you.
3. I can't speak for most people. What I can say is that I can think in C and I can think in Ruby, and it doesn't seem difficult for me.
"public static final" is not particularly verbose. It's a one time upfront cost which defines a few flags. It's error free, since a typo in any of those keywords will be picked up.
It can also be automated easily etc.
But Ruby using 'end' etc instead of curly braces, that's going to add up to a lot of verbosity.
Furthermore, variables can't be called. If you have a proc object in a variable, you use "myproc.call" to invoke it. The only ambiguity is between methods call within the same 'self' and local variables:
def foo
42
end
def bar
puts foo #=> 42
foo = 30
puts foo #=> 30
puts self.foo #=> 42
end
In practice this isn't a big problem. class Foo
attr_reader :bar
def initialize (num)
@bar = num
end
end
puts Foo.new(42).bar
attr_reader is a class-level method that defines a getter method for the named variable. There's also attr_writer, for setting, and attr_accessor, for both at once. public class Foo
int bar;
public Foo(int bar) {
this.bar = bar;
}
public int getBar() {
return bar;
}
public static void main(String[] args) {
System.out.println(new Foo(42).getBar());
}
}You should make bar private, and add a setter. After all, we might want to change the rules on setting bar sometime, and you wouldn't want to have to go back and change everywhere that accesses it...
It's package-access by default, that's enough to hide it from the third-party users of the class.
> and add a setter
The original code uses `attr_reader` which defines a readonly "property". The Java translation is a single getter, with no way to set the value from outside the class.
public class Foo
int bar;
public Foo(int initBar) {
bar = initBar;
}
public static void main(String[] args) {
System.out.println(new Foo(42).bar);
}
}2. let's say you solve this conundrum by making the field public
2.1. This piece of code is now frozen solid, you will not be able to ever refactor it (where refactoring is defined as changing implementation without changing behavior) since you can not transparently swap fields and methods in Java
2.2. This piece of code is dead to abstract types, as fields can not be part of interfaces in Java.
2.3. This piece of code is incompatible with Java Beans and will therefore be unusable in e.g. JSP taglibs
and your other points don't really make any sense at all. There is no such thing as 'fozen solid code'. Unless you're interfacing to external libraries etc and have agreed on a specific API, which is unlikely to include "yeah just reference 'bar' directly" unless you're insane.
I can't count the amount of time I wasted typing things like
LongVariableName longVariableName = new LongVariableNameImpl();
as a java programmer. Also the amount of extra typing for creating anonymous inner classes made GUI coding a real chore. Sure your IDE can automate lots of it, but emacs automatically types end for me when I type def so it's not even a consideration.Your comment comes across as someone who is either trolling or has no real experience in a language outside of java.
def some_method { ... }
def some_method; ... end
obj.something # "something" is allways a method
# never a var, say accessor (getter, setter &c ...)I'm just more at home with exact, specific concise well structured syntax.
I know it's an extremely unpopular opinion to hold, especially round these parts, but I don't see any beauty in Ruby syntax. Same with Python...
{} or do/end work for blocks, however.
It's all subjective, but I prefer concise, exact non ambiguous readable code.
From a google for 'ruby sample code'...
http://www.fincher.org/tips/Languages/Ruby/
Eugh brackets are optional for invoking functions? So I can no longer just look for () after a name to determine what is a function invocation? "end"? Seriously? Verboseness... (This is one of the things that for me, makes ruby very ugly. It's needless verbosity and doesn't have any advantage over using {} ). Yuck. So how do you know what's a function and what's a variable? Starting to look like cobol here... 'unless'? seriously? Why is that nicer than an if statement?Java code has a very exact, easy to parse syntax. We all know it, and it's easy to learn - {} for code blocks, () for method invocations, etc
That's just for starters.