general purpose language ruby

General Purpose Language
General Purpose Language
Ruby
Ruby
Kit Chan
Kit Chan
COMP3351
COMP3351
Programming Languages
Programming Languages
November 9, 2007
November 9, 2007

Outline
Outline

Reference
Reference

Introduction
Introduction

Ruby is
Ruby is

Features
Features


Array
Array

Loop
Loop

Ruby v.s. Java
Ruby v.s. Java

Duck Typing
Duck Typing

Dynamic Typing
Dynamic Typing

Type Tag Checking
Type Tag Checking

Functional Programming
Functional Programming

Reference
Reference

Wikipedia
Wikipedia
/> /> /> />
Ruby Official Website
Ruby Official Website

/> />
Learning Ruby
Learning Ruby
/> />
Duck Typing
Duck Typing
/> />
Introduction
Introduction

Developed by Yukihiro “Matz” Matsumoto, in Feb, 1993
Developed by Yukihiro “Matz” Matsumoto, in Feb, 1993

First released in 1995
First released in 1995

1.8.6 Ruby 1.9 developed March, 2007
1.8.6 Ruby 1.9 developed March, 2007

Named
Named

As a gemstone because of a joke with in Matsumoto’s friends alluding to
As a gemstone because of a joke with in Matsumoto’s friends alluding to
Perl’s name
Perl’s name

Ruby is
Ruby is


Cross-platform Operating System
Cross-platform Operating System

Combines syntax by
Combines syntax by

Perl
Perl

Smalltalk-like OO features
Smalltalk-like OO features

Shares features with
Shares features with

Lisp
Lisp

Python
Python

Dylan
Dylan

CLU
CLU

Ruby is
Ruby is


The interpreted scripting language for
The interpreted scripting language for

Quick
Quick

Easy OO programming
Easy OO programming

designed for programmer productivity
designed for programmer productivity

Straight-forward
Straight-forward

principle of least surprise (POLS)
principle of least surprise (POLS)

Ruby behaves in a way that minimizing confusion for
Ruby behaves in a way that minimizing confusion for
experienced users
experienced users

After you learn Ruby very well
After you learn Ruby very well

Ruby is
Ruby is

Obedient

Obedient
>> 'Hello World'
>> 'Hello World'
=> "Hello World”
=> "Hello World”

>> 'blink ' * 4
>> 'blink ' * 4

=> "blink blink blink blink "
=> "blink blink blink blink "

Your Calculator
Your Calculator
>> 1+1
>> 1+1
=> 2
=> 2
Or
Or
>> 2**2**2
>> 2**2**2
=> 16
=> 16

Features
Features

Object-oriented
Object-oriented


Four levels of variables:
Four levels of variables:

Global
Global
$var
$var

Instance
Instance
@var
@var

Local
Local
[a-z] or _; var
[a-z] or _; var

Constant
Constant
[A-Z]
[A-Z]

Exception handling
Exception handling

Iterators & closures
Iterators & closures


Automatic garbage collecting
Automatic garbage collecting

Highly portable
Highly portable
/> />
Array
Array

>> numbers = ["zero", "one", "two", "three", "four"]
>> numbers = ["zero", "one", "two", "three", "four"]

=> ["zero", "one", "two", "three", "four"]
=> ["zero", "one", "two", "three", "four"]

=> Array
=> Array

>> numbers[0]
>> numbers[0]

=> "zero"
=> "zero"
What arrays do?
What arrays do?



>> numbers[0].class
>> numbers[0].class


=> String
=> String

>> numbers[0].upcase
>> numbers[0].upcase

=> "ZERO"
=> "ZERO"

>> numbers[0].reverse
>> numbers[0].reverse

=> "orez"
=> "orez"

Loop
Loop

If I knew Ruby when I was in grade school…….
If I knew Ruby when I was in grade school…….

>> 100.times do
>> 100.times do

puts "I won't do that again"
puts "I won't do that again"

end
end


I won't do that again
I won't do that again














=> 100
=> 100

My life was going to be much easier
My life was going to be much easier

Ruby v.s. Java- Syntax
Ruby v.s. Java- Syntax

begin_time = Time.now.to_i
begin_time = Time.now.to_i

i = 0

i = 0

100.times do
100.times do

i += 1
i += 1

j = 0
j = 0

10.times do
10.times do

j += 1
j += 1

k = 0
k = 0

100.times do
100.times do

k += 1
k += 1

puts i.to_s + " + " + j.to_s + " + " + k.to_s
puts i.to_s + " + " + j.to_s + " + " + k.to_s

end

end

end
end

end
end

end_time = Time.now.to_i
end_time = Time.now.to_i

difference = end_time - begin_time
difference = end_time - begin_time

puts "It took " + difference.to_s + " seconds"
puts "It took " + difference.to_s + " seconds"

ho = gets
ho = gets

class test

{

public static void main(String[] args)

{

long startTime = System.currentTimeMillis();


for (int i=0; i<=100 ; i++ )

{

for (int j=0; j<=10 ; j++)

{

for (int k=0; k<=100 ; k++ )

{

System.out.println( i + " + " + j + " + " + k);}}}

long endTime = System.currentTimeMillis();

long difference = (endTime - startTime)/1000;

System.out.println("It took " + difference + "
seconds");

}

}

Ruby v.s. Java
Ruby v.s. Java

Performance
Performance


Ruby: 24 – 26 seconds
Ruby: 24 – 26 seconds

Java: 1 – 2 seconds
Java: 1 – 2 seconds
Language
Language
Paradigm
Paradigm
Type
Type
Checking
Checking
Java
Java

Imperative
Imperative

Object-oriented
Object-oriented

Generic
Generic
Static
Static
Ruby
Ruby


Imperative
Imperative

Object-oriented
Object-oriented

Functional
Functional

Aspect-oriented
Aspect-oriented
Dynamic
Dynamic
(duck)
(duck)

Duck Typing
Duck Typing

Ruby interpreter is happy to treat it as it were a duck
Ruby interpreter is happy to treat it as it were a duck

If an object walks and talks like a duck
If an object walks and talks like a duck

Duck typing means
Duck typing means

An object type is defined by what it can do
An object type is defined by what it can do


Not by what it is
Not by what it is

Duck typing refers to
Duck typing refers to

less concerned with the class of an object
less concerned with the class of an object

more concerned with what methods can be called on it
more concerned with what methods can be called on it

what operations can be performed
what operations can be performed

Duck Typing
Duck Typing

we use respond_to?
we use respond_to?

Example
Example

>> puts ('A string'.respond_to? :to_str)
>> puts ('A string'.respond_to? :to_str)

true
true


=> nil
=> nil

>> puts (Exception.new.respond_to? :to_str)
>> puts (Exception.new.respond_to? :to_str)

true
true

=> nil
=> nil

If an object quacks like a duck, just treat it as a
If an object quacks like a duck, just treat it as a
duck….
duck….

We should treat objects to the methods they define
We should treat objects to the methods they define

Duck Typing
Duck Typing

>> class Duck
>> class Duck



def quack

def quack



'Quack!'
'Quack!'



end
end



def swim
def swim



'Paddle paddle paddle '
'Paddle paddle paddle '



end
end



end

end



=> nil
=> nil

>> class Goose
>> class Goose



def honk
def honk



'Honk!'
'Honk!'



end
end



def swim
def swim


'Splash splash splash '
'Splash splash splash '



end
end



end
end



=> nil
=> nil



>>
>>

Duck Typing
Duck Typing

>> class DuckRecording
>> class DuckRecording


def quack
def quack



play
play



end
end



def play
def play



'Quack'
'Quack'



end
end


end
end



=> nil
=> nil

>>defmake_it_quack(duck)

duck.quack

end

=> nil

>>putsmake_it_quack(Duck.new)

Quack!

>>putsmake_it_quack(DuckRecording.new) 

Quack

=> nil

>> def make_it_swim(duck)


duck.swim

end

=> nil

>>putsmake_it_swim(Duck.new)

Paddlepaddlepaddle 

=>nil

>>putsmake_it_swim(Goose.new)

Splashsplashsplash 

=> nil



Add Method to Class Instances
Add Method to Class Instances

Add methods to individual class instances
Add methods to individual class instances

class Duck
class Duck


def quack
def quack

puts 'Quack!'
puts 'Quack!'

end
end

def swim
def swim

puts 'Paddle paddle paddle '
puts 'Paddle paddle paddle '

end
end

end
end

d = Duck.new #create new instance of the class
d = Duck.new #create new instance of the class

d.quack
d.quack
#call method
#call method

d.swim

d.swim
#call method
#call method

def d.walk
def d.walk
#override existing method with
#override existing method with
#new functionality
#new functionality

puts 'I am walking walking'
puts 'I am walking walking'

end
end

d.walk
d.walk

=> nil
=> nil

=> #<Duck:0x6cc7ddc>
=> #<Duck:0x6cc7ddc>

Quack!
Quack!

=> nil

=> nil

Paddle paddle paddle
Paddle paddle paddle

=> nil
=> nil

=> nil
=> nil

I am walking walking
I am walking walking

=> nil
=> nil

irb(main):022:0>
irb(main):022:0>

Dynamic Typing
Dynamic Typing

Ruby, the data types are not wholly declared on variable
Ruby, the data types are not wholly declared on variable

Data associated with variables are not known until the time of execution
Data associated with variables are not known until the time of execution

Advantage:

Advantage:

flexibility
flexibility

Less work for the programmer
Less work for the programmer

Type Tag Checking
Type Tag Checking

Ruby is dynamically typed
Ruby is dynamically typed

it supports run-time dispatch on tagged data
it supports run-time dispatch on tagged data

Takes place at run-time
Takes place at run-time

values bound in variables can acquire different tags depending on the
values bound in variables can acquire different tags depending on the
execution path
execution path

Example
Example

var x
var x

#declares the name x
#declares the name x

x :=1
x :=1
#associates int val 1 to name x
#associates int val 1 to name x

x :=“hi”
x :=“hi”
#associates the string val “hi” to name x
#associates the string val “hi” to name x

……………
……………
illegal
illegal

binding x to values of inconsistent type
binding x to values of inconsistent type

Pure Dynamically typed system allows the execution
Pure Dynamically typed system allows the execution

Type tags are attached to values
Type tags are attached to values

Dynamic typing catches errors during program execution
Dynamic typing catches errors during program execution

Example cont
Example cont

Dynamic typing keeps all program values “tagged”
Dynamic typing keeps all program values “tagged”

Checks the tag before using any value in an operation
Checks the tag before using any value in an operation

var x :=1
var x :=1
#binds val 1 to x
#binds val 1 to x

var y := “hi”
var y := “hi”
#binds val “hi” to y
#binds val “hi” to y

var z := x + y
var z := x + y
#add x to y
#add x to y

Example cont
Example cont

The value bound to x be a pair (integer, 1)
The value bound to x be a pair (integer, 1)


The value bound to y be a pair (string, “hi”)
The value bound to y be a pair (string, “hi”)

Attempts to execute the 3
Attempts to execute the 3
rd
rd
line,
line,

Checks the type tags integer and string
Checks the type tags integer and string

If the operation + (addition) is not defined
If the operation + (addition) is not defined

An error is signaled
An error is signaled

Why Ruby?
Why Ruby?

High productivity for programmers
High productivity for programmers

Execution time is not the main concern
Execution time is not the main concern

Web Developments
Web Developments


Projects like Ruby on Rails
Projects like Ruby on Rails

Functional Programming
Functional Programming

Paradigm treats computation as the evaluation of mathematical
Paradigm treats computation as the evaluation of mathematical
functions
functions

Emphasize on application of functions
Emphasize on application of functions

Largely being used in academia
Largely being used in academia

Lambda calculus
Lambda calculus

Forms the foundation for most models of functional programming
Forms the foundation for most models of functional programming

Thank you !!
Thank you !!