Psalm Mizuki

Ruby Psalm Mizuki

Summary  Background  What

Ruby is Good for  Design Principles of Ruby  Some Features of Ruby  Surprising/Confusing Things in Ruby

A Little Background  Originated

in Japan during the 1990’s  Developed and designed by Yukihiro Matsumoto  Based on Perl, Smalltalk, Python, and CLU – Multiple paradigms

Things Ruby is Good for  Text

Processing

– File, String, and Regexp classes  CGI

– – – –

Programming

Text-handling classes CGI library DB interface Embedded Ruby and mod_ruby for Apache

Things Ruby is Good for 

Network Programming – Well-designed socket classes



GUI Programming – GUI toolkit interfaces  Ruby/Tk  Ruby/Gtk



XML Programming – – –

Text-handling features UTF-8-aware regex engine Interface to expat XML parser library

Things Ruby is Good for  Prototyping

– High productivity – Prototypes can become production systems by replacing bottlenecks with C-written extensions  Programming

Education

– Based on a variety of different languages – Considered by some as a scripting language, so people can quickly start to write programs

Design Principles  Principle

of Conciseness  Principle of Consistency – Principle of Least Surprise  Principle

of Flexibility

Principle of Conciseness  “I

want computers to be my servants, not my masters. Thus, I’d like to give them orders quickly. A good servant should do a lot of work with a short order.”

Principle of Consistency  Uniform

object treatment  Small set of rules covers all of Ruby

Principle of Least Surprise  Someone

with a basic knowledge of programming languages can learn Ruby quickly  Principle of Least Surprise does not mean that no one will ever be surprised by anything that they see in a language

Principle of Flexibility  Ruby

has a relatively small amount of syntax that is unchangable, and pretty much everything else is done in extensible class libraries  User-defined objects can be treated like built-in ones

Features  Object-oriented

design  Classes with inheritance  Mixins  Iterators  Closures (Blocks)  Garbage collection

Features from Smalltalk Dynamic: no static type information used  Purely object-oriented: all values are objects, including classes 

– All procedures are a method of some object, even things that look like function calls

Designed to be object-oriented from the outset (unlike Perl)  Has garbage collection 

Differences from Smalltalk  No

really weird syntax  Operators follow usual operator precedence (2+3*4 == 2+(3*4))  There is separation between the programming language itself and its interpreter

Features from Perl and Python 

Considered in some ways a scripting language – Support a fast development cycle because compilation isn’t needed – Require less code to get things done – Strong set of built-in libraries that supports text and file handling

  

Syntax Portable Free

Differences from Perl  Fewer

sigils  Less context-dependent  Fewer implicit type conversions  While most Perl functions exist in Ruby, they are organized into class libraries  Slightly slower, but more concise

Differences from Python  Don’t

use indentation to structure

code  No conversion between small and large integers  Don’t need to maintain reference counts in extensions  More syntax  Faster

Features  Object-oriented

design  Classes with inheritance  Mixins  Iterators  Closures (Blocks)  Garbage collection

Inheritance and Mixins  Ruby

uses single inheritance to avoid problems with multiple inheritance  Uses mixins to get something similar to multiple inheritance, without the problems that can be introduced by multiple inheritance

Inheritance and Mixins  Mixin:

similar to an interface in Java, but you provide the implementation  Have no explicit superclasses  Cannot be instantiated  Also called modules (actually type module when defining a mixin in Ruby code)

Features  Object-oriented

design  Classes with inheritance  Mixins  Iterators  Closures (Blocks)  Garbage collection

Iterators 

Don’t use loops to iterate over objects – Only loops that are implemented in Ruby are the while loop and until loop



Objects are in charge of their own traversal – This avoids errors with indices



Use code blocks to customize behavior of iteration

Features  Object-oriented

design  Classes with inheritance  Mixins  Iterators  Closures (Blocks)  Garbage collection

Closures (Blocks) A

block is code that is either found between curly braces or between a do and end  Similar to anonymous methods  Can be passed around as parameters and stored in variables  Great for transactions  Inspired by Lisp

Features  Object-oriented

design  Classes with inheritance  Mixins  Iterators  Closures (Blocks)  Garbage collection

Garbage Collection  Uses

a mark and sweep method of garbage collection  Scans C stack and registers – This way extensions don’t need to maintain reference counts or protect local variables  No

INCREF/DECREF and no mortal

Some Surprising Things  Duck/Dynamic  Scoping  Truth  Open

classes

typing

Duck Typing  If

it walks like a duck and quacks like a duck, then it must be a duck  Define an object by what it can do, not its type  Powerful for prototyping – Can customize as development progresses

Scoping  Use

sigils to determine the scope of a variable  Can make things slightly awkward if you’re used to Perl

Scoping Scope

Prefix/Sigil

Global variable $

Example $global

Instance @ @instance variable Local variable Lowercase or _ local/_local Constant

Uppercase

Class variable @@

Constant @@class_var

Truth  In

Ruby, everything except for nil and false is considered true

Open Classes  All

classes can be edited  Even core classes  If you don’t know what you’re doing, this can be very, very bad… – If you do know what you’re doing, however, this could be fun and convenient

Questions?

References  



“About Ruby.” http://www.ruby-lang.org/en/about/. “Ruby From Other Languages.” http://www.ruby-lang.org/en/documentation/rub . Yukihiro Matsumoto. “The Ruby Programming Language.” http://www.informit.com/articles/article.aspx?p= .

References  Yukihiro

Matsumoto. “The Top Ten Reasons Why the Ruby Programming Language Sucks!” Ruby-Doc. 2003. 1 November 2009. < http://ruby-doc.org/docs/The%20Top%20 >.

Thank you for your time and attention.