Introducing Ruby

“like Smalltalk plus Perl
... but with better syntax”

• a general-purpose programming language
• truly object-oriented
• dynamic typing
• exception-handling
• garbage-collection
• multi-threading

“quick and clean …
the glue that doesn’t set”

• not just for “scripting”
• strives to be programmer-friendly
• following “the Principle of Least Surprise”

The rise of Ruby

Ruby compared to Java

• everything is an object
  • even “primitives”, and classes, and methods

• dynamic typing
  • variables don’t have types—values (ie. objects) do
  • no such thing as an “interface”

• interpreted, not compiled
  • can change code at runtime!

• Ruby has:
  • blocks (anonymous functions) and closures (like Lisp)
  • “mix-in” modules (multiple inheritance of implementation)
  • operator overloading
  • reflection and “meta-programming” features

• Java has:
  • a virtual-machine
  • compilation to byte-code
  • class-loaders
  • security managers

Hello, world!

class Greeting { 
    public static void main(String args[]) { 
        System.out.println("Hello, world!"); 
    } 
} 

puts "Hello, world!" 

Making a Point

class Point { 
    private float x, y;
    public Point(float x, float y) { setX(x); setY(y); }
    public float getX() { return this.x; } 
    public void setX(float x) { this.x = x; } 
    public float getY() { return this.y; } 
    public void setY(float y) { this.y = y; } 
}

Point p = new Point(1,2);
p.setX(10);

class Point 
    def initialise(x, y); @x=x; @y=y; end
    def x(); @x; end
    def x=(x); @x = x; end
    def y(); @y; end
    def y=(y); @y = y; end
end 

p = Point.new(1,2)
p.x = 10

Making a Point

class Point { 
    private float x, y;
    public Point(float x, float y) { setX(x); setY(y); }
    public float getX() { return this.x; } 
    public void setX(float x) { this.x = x; } 
    public float getY() { return this.y; } 
    public void setY(float y) { this.y = y; } 
}

Point p = new Point(1,2);
p.setX(10);

class Point 
    def initialise(x, y); @x=x; @y=y; end
    attr_accessor :x, :y
end 

p = Point.new(1,2)
p.x = 10

Making a Point

class Point { 
    private float x, y;
    public Point(float x, float y) { setX(x); setY(y); }
    public float getX() { return this.x; } 
    public void setX(float x) { this.x = x; } 
    public float getY() { return this.y; } 
    public void setY(float y) { this.y = y; } 
}

Point p = new Point(1,2);
p.setX(10);

Point = Struct.new(:x, :y)

p = Point.new(1,2)
p.x = 10

Kicking goals

Map fifaTitlesByTeam = new HashMap();
fifaTitlesByTeam.put("Brazil",    new Integer(5));
fifaTitlesByTeam.put("Italy",     new Integer(3));
fifaTitlesByTeam.put("Germany",   new Integer(3));
fifaTitlesByTeam.put("Argentina", new Integer(2));
fifaTitlesByTeam.put("Uruguay",   new Integer(2));
fifaTitlesByTeam.put("France",    new Integer(1));
fifaTitlesByTeam.put("England",   new Integer(1));

fifa_titles_by_team = {
    "Brazil"    => 5,
    "Italy"     => 3,
    "Germany"   => 3,
    "Argentina" => 2,
    "Uruguay"   => 2,
    "France"    => 1,
    "England"   => 1
}

Going loopy

Collection teams = new ArrayList();

for (Iterator i = fifaTitlesByTeam.keySet().iterator(); i.hasNext();) {
    String team = (String) i.next();
    int titles = ((Integer) fifaTitlesByTeam.get(team)).intValue();
    if (titles > 1) {
        teams.add(team);
    }
}

System.out.println(StringUtils.join(teams.iterator(), ", "));

teams = []

fifa_titles_by_team.each do |team, titles|
  teams << team if (titles > 1)
end

puts teams.join(", ")

Blocks

iterating

files.each do |f| 
    message.attach(f)
end

delineating database transactions

db.transaction do |t|
  t.execute("update EMPLOYEES set SALARY = 1000000")
end

file processing

File.open(log_file) do |log_file_handle|
    log_file_handle.each_line do |line|
        cksum << line
    end
end

Introducing Ruby on Rails

• The current Ruby “killer app”

• a Ruby web application framework, comprising:
  • Model-View-Controller separation
  • object/relational mapping
  • page templating

• plus support for:
  • AJAX
  • web services (SOAP, XML-RPC, REST)
  • sending email
  • automated testing
  • evolving your database schema

Rails: “Opinionated software”

• Simplicitly, with attitude
• Convention over configuration
  • sensible defaults
  • standardised source-directory layout
    • models go here
    • views go here
    • controllers go here
    • configuration goes here
    • tests go here
  • tables should have surrogate keys
  • class “Person” maps to table “PEOPLE”
  • stored-procs are evil

Rails vs the J2EE technology stack

Hello World – Struts Action Framework

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" 
                       "http://www.opensymphony.com/xwork/xwork-1.0.dtd">
<xwork>
    <include file="action-default.xml"/>
    <package name="default" extends="action-default">
        <action name="helloWorld" class="eg.HelloWorld">
            <result name="success">helloWorld.jsp</result>
        </action>
    </package>
</xwork>

package eg;

import com.opensymphony.xwork.Action;
import java.util.*;

public class HelloWorld implements Action {

    private String greeting;
    private String subject;

    public void setGreeting() {
        this.greeting = greeting;
    }

    public void setSubject() {
        this.subject = subject;
    }

    public String execute() {
        if (greeting == null) {
            greeting = "Hello";
        }
        if (subject == null) {
            subject = "world";
        }
        return SUCCESS;
    }

    public String getGreeting() {
        return this.greeting;
    }

    public String getSubject() {
        return this.subject;
    }

}

<%@ taglib prefix="saf" uri="action2" %>
<html>
<body>

<h1><saf:property value="greeting"/>, <saf:property value="subject"/>!</h1>    

</body>
</html>

Hello World – Rails

class HelloController < ApplicationController

  def index
    @greeting = params['greeting'] || "Hello" 
    @subject  = params['subject']  || "world" 
  end

end

<html>
<body>

<h1><%=h @greeting %>, <%=h @subject %>!</h1>    

</body>
</html>

Object/Relational mapping – Hibernate

<hibernate-mapping>
    <class name="events.Event" table="EVENTS">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="title"/>
        <property name="date" type="timestamp"/>
        <set name="participants" table="EVENT_PARTICIPANT">
            <key column="EVENT_ID"/>
            <many-to-many column="PERSON_ID" class="events.Person"/>
        </set>
    </class>
</hibernate-mapping>

<hibernate-mapping>
    <class name="events.Person" table="PERSON">
        <id name="id" column="PERSON_ID">
            <generator class="native"/>
        </id>
        <property name="age"/>
        <property name="firstname"/>
        <property name="lastname"/>
    </class>
</hibernate-mapping>

• Not shown:
  • Event and Person classes
  • Hibernate SessionFactory configuration
  • table definitions

Object/Relational mapping – Rails

class Person < ActiveRecord::Base
end

class Event < ActiveRecord::Base

  has_and_belongs_to_many :participants, 
      :class_name => "Person" 

end

• Not shown:
  • table definitions

Meta-Programming and Domain-Specific Languages

• Meta-programming: programs that write/manipulate other programs

• Domain-Specific Languages: programming in your problem domain
  • “external” DSL – parser, interpreter, code-generator
  • “internal” DSL – leverage an existing language

• “internal DSL” is synonymous with “API”

• building “internal” DSLs in Ruby is easy because of:
  • blocks
  • dynamic typing
  • meta-programming features
  • did I mention blocks?

DSL example: ActiveRecord Migrations

create_table :events do |table|
  table.column :title,          :string
  table.column :date,           :date
end

create_table :people do |table|
  table.column :first_name,     :string
  table.column :last_name,      :string
  table.column :age,            :integer
end

create_table :events_people, :id => false do |table|
  table.column :event_id,       :integer
  table.column :person_id,      :integer
end

Performance/scalability

Myth: “scripting” languages can’t scale

• Counter-examples:
  • Slashdot (Perl)
  • Yahoo! (PHP)
  • BitTorrent (Python)

• Reality:
  • bottlenecks are typically network, database

• Rails scales much like PHP/Perl/Python
  • across processes, rather than threads
  • front-end web server serves static content
  • “shared nothing” architecture
    • usually means shared database
    • don’t store state in application servers

One possible Rails deployment architecture

Notable public Rails applications

• 37signals – Basecamp, Campfire, Backpack, Writeboard
  • home of Rails architect David Heinemeier Hansson

• Robot Co-op – 43things, 43places, 43people
  • over 2,000,000 hits/day

• odeo – podcast aggregator

• Penny Arcade – popular online comic

• A List Apart – popular online web development magazine

Some Ruby/Java integration options

• Web services
  • XML over HTTP is easy
  • WS-* support is lacking
  • opinion: Rails will become a leading platform for REST web services

• Asynchronous messaging

• JRuby
  • port of the Ruby interpreter to Java
  • Ruby-1.8.2 compliant (mostly)
  • can (almost) run Rails

Using Rails – recommendations

Use

• for “Web 2.0”, AJAX-heavy apps
• for prototypes/pilots
• when you need to deliver quickly
• with small, agile teams
• and you have control of the database

Avoid

• when you’re stuck with a “legacy” database
• if you don’t have a testing culture
• if you fundamentally disagree with the underlying “opinions”

Using Ruby – recommendations

Use

• for text processing
• for code/test/data generation
• to automate build/testing tasks
• wherever you’re currently using Perl, Python, PHP, Bourne-shell
• for general integration—to “glue” things together

Which IDE do you use?

Finding a Ruby developer

Large global organisation seeks Senior Developer/Architect.
2-3 years Ruby/Rails experience required.

Remember:

• Ruby is extremely easy to learn
• most Rails developers were doing PHP/Java/.Net/Perl a year ago

Finding a Ruby developer

Look for transferable skills:

• object-oriented design skills
• (for Rails) general web development skills
• experience with other dynamically-typed languages
• knowledge of the business domain
• someone who already works for you

Finding a Ruby consultant

Where to now?

http://www.ruby-lang.org

http://www.rubyonrails.org

(recently-formed)
Melbourne Ruby users group

THE END