Ruby is a bit funny about Windows. It's usually distributed with some emulated Unix tools.

Emacs has ruby-mode and org-babel support for Ruby build in. Just add (ruby . t) to the org-babel-load-languages alist.

On the command line, there is a read-eval-print-loop (REPL) called irb, for Interactive Ruby.

Since version 2.0, Ruby uses utf-8 as default. Good.

Lines starting with # are comments.

All lines between =begin and =end are too.

Comparison operator: a <=> b. This is also sometimes called the spaceship operator. It returns an integer telling us whether a is less than, equal to, or greater than b.

.. and ... are the open and closed range operators.

|| and or are or, but the latter has low operator precedence.

Null coalescing method calls: &..

Most variables are references to an object. Some variables are primitive types (in Ruby, these are called immediate values), which get stored directly.

As with Java, C#, and most other recentish languages, what we are usually doing most of the time is call by value, but the value we pass is a reference (except for the primitive types mentioned above, which are immutable anyway).

There is no call by reference like R's promises or <<- operator.

You can use * on the left hand side of a variable assignment to create an array, or on the right hand side to destructure/expand one.

Variables have some different properties depending on their first character:

$

evil global variable

@

instance (this object)

[a-z_]

local (lives as long as current scope/environment)

[A-Z]

constant (warning if you try to redefine)

You can put hooks on global variables, which fire when they are set.

There are some useful built-in globals.

For constants, it's usually a good idea to put them in a Module.

Variables start out as nil, except for local variables. Local variables must be assigned to before use.

There's a ternary operator, which looks like C or Perl: condition ? trueResult : falseResult.

There's also an if/elsif/end branching statement:

if true == false
  "Logic is broken!"
elsif 2 + 2 == 5
  "A boot stamping on a human face — FOREVER!"
else
  "Nothing to see here, move along."
end

Nothing to see here, move along.

You can use until instead of if not. This may or may not be more readable. Use judgement.

There's also a kind of guard clause, which in Ruby is called an if modifier puts "true" if true.

Lastly, we have a switch statement, which uses JavaScript-style type-coerced matching:

case "oy"
when "nope"
  false
when "yep"
  true
when /\w+/
  "regex match"
end

regex match

We have while, until and for. Like blocks, they finish with end. Until is just the negation of while — don't confuse it for do...until from other languages.

Unlike blocks, they don't create a new scope.

While has an additional form similar to the if modifiers:

i = 7
puts i+=1 while i < 10

8
9
10

Loops have a redo statement, which repeats the current iteration, and a retry statement, which tries to repeat the whole loop.

In Ruby, we often prefer an iterator to a loop.

Use the do and end do ... end keywords, or braces { ... }.

They introduce a new scope for variables. Variables from outside the block used inside the block aren't shadowed. You can modify that variable directly.

Declare parameters as |a, b, c|.

Only false and nil are falsey values. The empty list, empty string, empty set, and so on, are all truthy.

Symbols are prefixed with a colon, like in Clojure: :symbol. They are interned (deduplicated and cached).

You can use them to access variables. binding.local_variable_get(:symbol) or eval("{#:symbol}").

You can write a range with ... Ranges have a to_a() method which returns an array.

puts 0..5
puts ("a".."z").to_a.join("")

0..5
abcdefghijklmnopqrstuvwxyz

Array literals look like Python [1, 2, 3].

You can index into arrays, and use negative numbers to index from the end. You can use a pair of values or a range to slice an index. Ranges are considered open for this purpose.

puts [0, 1, 2, 3, 4, 5][3]
puts [0, 1, 2, 3, 4, 5][0, 3].join("")
puts [0, 1, 2, 3, 4, 5][0..3].join("")

3
012
0123

The << operator appends to an array:

a = [0, 1, 2, 3]
a << 4

a.join("")

1234

Strings are mutable in Ruby. This is likely to change in Ruby 3.0. You can also make your strings immutable by called the freeze method on them.

There are single-quoted and double-quoted string literals.

Single-quoted strings have simpler escaping rules (like Python's raw strings). Double-quoted strings allow expression interpolation using #{}.

Objects have a to_s method (convert object to string).

You can concatenate strings with +, and duplicate then with *.

You can use array indexing and slicing on them.

puts "a" + "b" * 5
puts "hello"[0,3]
puts "hello"[3..-1]

abbbbb
hel
lo

You can convert between strings and arrays using the split and join functions on objects of those types.

The chop function strips trailing whitespace.

"\n\thello    \t\n\n".chop()

hello

There are useful iterators on string like each_byte and each_line.

Large integers are automatically taken care of since Ruby 2.4.

There's an r syntax for representing rational numbers (fractions).

There's an i syntax for imaginary parts of numbers.

In Ruby they're called hashes.

Created as: {key => value, key2 => value2}.

If you're using symbols as keys, there's a shorted syntax: {key: "value", key2: "value2"}.

Hashes in Ruby have a to_proc method, which spit out an anonymous function. This can be good for shinking your code.

As with C# and Python, we use the yield keyword to create an iterator. Unlike C# and Python, the job of this keyword is to pass the control flow to a block. It's inside out compared to those languages. The iterator is the calling part of code.

In Java or C#, you write some code to make something iterable, and then passing it to general methods which operate on it like map or reduce, along with a (usually anonymous) function to do something on the way. This is an external iterator.

In Ruby, you instead implement map or reduce separately on each type of collection as an iterator method. The iterator itself then takes your anonymous function. This is an internal iterator.

Ruby's Enumerable class does both. It also provides lots of helpful methods for operating on them (for example: chunking, lazy evaluation).

You can use the redo and retry keywords inside a function. They often provide a neat way to implement an iterator. I don't really understand this yet.

TODO: this is something to revisit once I've actually used the language a bit more.

Declared with def.

Method calls without arguments can omit the parentheses. This can lead to some ambiguity, so be careful.

Ruby is really into OO. If you define a function outside of a class, they are actually a private method of the Object class, which is the root of the whole class hierarchy.

You can use the self variable to get the object a method was dispatched on. You don't need to include this in the method signature: it's implicit.

Varargs is done the same way as in Python: using *, like def blah(first, *rest). You can also use it at method call time to apply an array as multiple arguments. This mirrors the variable assignment destructuring and array creation syntax.

Method arguments can have default values, using the same syntax as in every over language.

Like R or a Lisp, Ruby returns the last value in an function — you don't need a return statement unless you want an early exit.

Modules are stripped down classes. Class is a subclass of Module.

Their main use is for mixins, but they can also be a useful bundle of static methods.

module MyModule
  def InstanceThingy()
       5
  end

  def self.StaticThingy()
       4
  end
end

puts MyModule.StaticThingy

4

Use the class keyword, instantiated with new ClassName. When you create an object, it goes on the heap.

As mentioned earlier, classes are instances of the class Class. This allows some metaprogramming.

Classes can have:

method definitions

def method(args)

attributes

attr :attr_name.

visibility controls for methods

private :symbol, protected :symbol and public :symbol.

mixins

include SomeClass

Objects have a send(symbol) function which does dispatch on a symbol match a method name: thing.send(:methodname).

They also have a method(symbol) function which gets a method object: thing.method(:methodname).call.

You can inspect the methods on a class using instance_methods(SomeClass).

Packages are called Gems. The gem command-line tool fetchs them and their dependencies.

The load command is fetches code from a *.rb file.

require is the better one to us normally. It can also load binaries, and it prevents multiple imports of the same feature.

STDIN.gets

puts / print

output to stdout, puts ensures the string ends with a newline

STOUT.flush

make sure everything gets written out

ARGV

array of command line arguments

open

open a file. The file will need closing when we're done, which is usually best done inside an ensure block.

TODO: Need to play with this a bit more.

Throw exceptions using raise (or fail, which is an alias for raise):

raise 'Oh dear! Abandon ship!'

Ruby has its own special naming scheme for handling exceptions:

begin

try

rescue[exception_type]

catch/except — may be used multiple times

ensure

finally

end

closing brace

There's a built-in global variable — $! — which holds the last exception.

It's a convention to name methods which change state with an ! and those which are a boolean test with ?. Often both destructive and non-destructive versions of methods will exist.

Variables names are usually written with underscores between words.