What are the most important things to know about Ruby?

Question

I am new to the language and I need to know what are the top things that are absolutely necessary to know in order to make a fully functional website or web app using the Ruby programming language?

Mainly Ruby on Rails with Rake and other tools that mainly use Rake.

Update: I know many other languages like C++, Java, PHP, Perl, etc, etc ....

Update 2: This is great ... keep 'em coming!

Answer 1

nobody would have ever heard of it if it wasn't for Rails?

Answer 2

Everything is an object. Everything.

Answer 3

Everything (except false and nil) evaluates to true in a boolean context.

This is different from other languages where empty constructs or 0 frequently evaluate as false.

if 0
    puts "0 evaluates to true"
end

Answer 4

irb, pp, lp & ap are very helpful magic words! ;)

1. http://github.com/oggy/looksee = lp
2. http://github.com/michaeldv/awesome_print = ap

Answer 5

Ruby uses message passing, not function calls.

e.g.,

# These are all the same:
5 + 3
5.+(3)
5.send(:+, 3)

Answer 6

1. You can use ruby modules as mixins where your design requires multiple inheritance
2. Every method returns the value of its last statement as the value of the method though you can use return where you want to be more explicit.
3. You can open any class again and add methods to it, called monkey patching which can be very powerful if used sensibly otherwise hell will break.
4. You can pass a block of code to any method and operate on it, e.g. in ruby world most of the time coders use iterators instead of for loops.
5. Where possible use symbols instead of strings because they are efficient, e.g. in hash keys

etc..

Answer 7

If a method Ruby doesn't know about is called, Ruby will then call method_missing with the details.

class MyClass
  def method_missing(method_name, *args)
    puts "Method #{method_name} called with arguments #{args.join(', ')}"
  end
end

my_instance = MyClass.new
my_instance.undefined_method(4, :blah)  # => Method undefined_method called with arguments 4, blah

Answer 8

Strings are mutable; Symbols are not.

Answer 9

Don't abuse monkey patching. Ruby makes it easy, but it can hurt.

See also http://stackoverflow.com/questions/293236/monkey-patching-vs-s-o-l-i-d-principles

Answer 10

Methods implicitly return the result of the last statement.

def foo
  "bar"
end

puts foo # outputs "bar"

Answer 11

You can't overload operator= just like you did in C++. You also can't simulate it in any way that makes sense.

Answer 12

A worth full read:-

Top 5 New Features in Ruby 1.9

1. YARV - Yet Another Ruby VM
2. Fibers
3. Named Regexp Groups

4.The Lambda Operator

5.RubyGems and Rake are Merged with Ruby

Answer 13

Almost everything is an expression that returns a value. This includes things you might not normally think of as expressions, such as class definitions — a class definition evaluates to the last expression inside of it. Likewise, if and case are expressions that evaluate to same result as the last expression in whichever branch was taken.

Exactly what they evaluate to if not always immediately obvious, though: def evaluates to nil, but define_method evaluates to a Proc representing the method it defined. This combined with the fact that a class definition is an expression sometimes surprises people:

class A
  define_method(:foo) {"hello"}
end

# => #<Proc:0x0001d718@(irb):18> # NOT nil

class A
  define_method(:bar) {"hello"}
  FAVORITE_NUMBER = 80
end

# => 80

Answer 14

If you actually know how to program, you already know the most important things to know about the Ruby Programming language. Just follow them.

The rest is in the stack of manuals; read them.

Answer 15

ruby-debug is your friend. I probably use it more than any other gem. Given ruby's dynamic nature it's hard to know exactly what a particular piece of code does by looking at the text in your editor. Just throw a 'debugger' in front of it and step into it.

it's also a great way to find out where a dynamically generated method is coming from.

Answer 16

Rack. All modern Ruby web servers and frameworks use the Rack protocol. Although you can make a Ruby web app without knowledge of Rack, it will give you a good foundation and it is becoming increasingly more important in the Ruby web community.

Rack may also make a good starting point for learning to program web apps in Ruby, since you can start with the simplest web app:

run lambda { |env| [200, {}, "hello world"] }

and you can keep building from there. After you understand Rack, the architectural decisions in Sinatra, Rails, etc. make more sense.

http://rack.rubyforge.org/

Answer 17

v 1.9 is very very different than v 1.8. Code built for 1.8 is NOT guaranteed to work in 1.9, and vice versa.

I had a whole bunch of code that worked in v 1.8 and didn't in v 1.9, and then had to deal with two machines that had different versions on each. Not fun.

Make sure to choose a version (probably the latest, but be wary that a lot of sample code in blogs on the web is 1.87, as is the second edition of Programming Ruby. There's since been released a third edition of Programming Ruby that covers 1.9, and that's the one you want.

Also, if you're at all like me, you'll be singing one of three songs while programming it:

• Ruby Soho-- Rancid
• Ruby Blue-- Róisín Murphy
• Ruby-- Kaiser Chiefs

Answer 18

I think people have covered most of the basics here. Here's some advanced stuff:

inherited, included, class_eval, instance_eval and:

@a = "something"
class << @a
  def moo
    puts "moo"
  end
end
@a.moo
@b = "something else"
@b.moo

eval is evil. Never use it unless you really, really, really know what you're doing.