Rubyforjavaprogrammers 1210167973516759-9

Ruby for Java
Programmers
Mike Bowler
President, Gargoyle Software Inc.

Timeline: 1993 to
2000
Created in 1993 by
Yukihiro "Matz"
Matsumoto
Ruby was popular in
Japan but unknown
everywhere else
All documentation
was written in
Japanese

Timeline: 2000-
2004
First English language
book published in 2000
A lot of interest in the
Agile development
community but mostly
unknown elsewhere

Timeline: 2004-
today
The Ruby on Rails
framework has pushed
ruby into the spotlight
This is the “killer app”

Terminology
Early
Late
Static
Dynamic
Strong
Weak

Defining strong/weak
typing
Strong typing
Objects are of a specific type and will not be
converted automatically
Java: “4”/2 results in a compile error
Weak typing
Objects can be converted under the covers at
any time
Perl: ‘4’/2 => 2
Ruby is strongly typed

Early/late
bindingEarly binding (aka static binding)
All method invocations must be defined at compile
time
Java: foo.getUser()
Late binding (aka dynamic binding)
The runtime does not check that a given method
exists until an attempt to invoke it
Smalltalk: foo user.
Ruby uses late binding

Similarities
Like Java, Ruby...
runs on a virtual machine
is garbage collected
is object oriented (although to different
degrees)

Differences
Everything is an object
Java
string = String.valueOf(1);
Ruby
string = 1.to_s()
Primitive
Object

Differences
Many things that you would expect to be
keywords are actually methods
throw new IllegalArgumentException("oops");
raise TypeError.new("oops")
Keywords
Methods

Differences
Some syntax optional unless the result is
ambiguous
These statements are equivalent
puts("foo");
puts "foo"
Idiomatic (better) style

Differences
Classes are real
objects
They’re instances of
Class
Class methods can
be overridden

class ZebraCage < Cage
attr_accessor :capacity
@@allCages = Array.new
def initialize maximumZebraCount
@capacity = maximumZebraCount
@@allCages << self
end
private
def clean_cage
# do some stuff here
end
end
cage = ZebraCage.new 10
puts cage.capacity

Multiline if
if name.nil?
do_something
end

Multiline if
if name.nil?
do_something
end
Notice the
question mark

With an else
if name.nil?
do_something
else
something_else
end

Single line if
if name.nil?
do_something
end
do_something if name.nil?

Both kinds of
unlessif name.nil?
do_something
end
do_something if name.nil?
unless name.nil?
do_something
end
do_something unless name.nil?

Dangerous methods
name = " foo "
name.strip
name.strip!
Returns a new string.
Doesn’t modify name.
Modifies name
and returns that.
Dangerous!

Philosophy
Java focuses on building blocks
You can build whatever you want with the
pieces
Ruby focuses on solving problems
Things you do frequently should be concise

Initializing
arraysList<String> list = new ArrayList<String>();
list.add("foo");
list.add("bar");

Same only ruby
List<String> list = new ArrayList<String>();
list.add("foo");
list.add("bar");
list = Array.new
list << 'foo'
list << 'bar'

[]
list.add("foo");
list.add("bar");
list = Array.new
list << 'foo'
list << 'bar'
list = ['foo', 'bar']

%w()
list.add("foo");
list.add("bar");
list = Array.new
list << 'foo'
list << 'bar'
list = %w(foo bar)

In fairness to
java...List<String> list = new ArrayList<String>();
list.add("foo");
list.add("bar");
List<String> list = Arrays.asList("foo", "bar");
list = Array.new
list << 'foo'
list << 'bar'
list = %w(foo bar)

Same idea with
hashes
Map<String,String> map
= new HashMap<String,String>();
map.put("foo", "one");
map.put("bar", "two");
map = {'foo' => 'one', 'bar' => 'two'}

Special case for
Hash
hash = {:a => 5, :b => 3}
do_stuff 30, hash
do_stuff 100, :a => 5, :b => 3

Regular
Expressions
Pattern pattern = Pattern.compile("^s*(.+)s*$");
Matcher matcher = pattern.matcher(line);
if( matcher.matches() ) {
doSomething();
}

Regular
Expressions
Pattern pattern = Pattern.compile("^s*(.+)s*$");
Matcher matcher = pattern.matcher(line);
if( matcher.matches() ) {
doSomething();
}
do_something if line =~ /^s*(.+)s*$/

Nil and Null
Java’s nullJava’s null Ruby’s nilRuby’s nil
Absence of an object An instance of NilClass
if( a != null ) {...} unless a.nil? {...}
null.toString() -> NPE nil.to_s -> “”
null.getUser() ->
Exception in thread "main"
java.lang.NullPointerException
nil.get_user ->
NoMethodError: undefined method
‘get_user’ for nil:NilClass

Implications of
late binding
Method dispatch is quite different
Ruby makes a distinction between “messages”
that are sent to an object and the “methods”
that get dispatched

What if there isn’t a
method for the
specified message?

method_missing
example from
ActiveRecord
user = Users.find_by_name(name)
user = Users.find(:first,
:conditions => [ "name = ?", name])

Creating proxy
objects
Mock object for testing
Proxy object to allow distributed objects across
machines
Wrapper to record usage of a given object

Implementing a
proxyclass Proxy
def method_missing name, *args, &proc
puts name,args
end
end

Implementing a
proxyclass Proxy
puts name,args
end
end
Proxy.new.foo_bar ‘a’
Proxy.new.to_s
Dispatches to
method_missing
Doesn’t go to
method_missing

Overriding to_s
class Proxy
puts name,args
end
def to_s
method_missing :to_s, []
end
end

=•===•=~•__id__•_send__•class•clone•dclone
display•dup•enum_for•eql?•equal?•extend freeze
frozen?•hash•id•inspect•instance_eval instance_of?
instance_variable_defined•instance_variable_get
instance_variable_get•instance_variable_set
instance_variable_set•instance_variables•is_a?
kind_of?•method•methods•new•nil?•object_id
private_methods•protected_methods•public_methods
remove_instance_variable•respond_to?•send
singleton_method_added•singleton_method_removed
singleton_method_undefined•singleton_methods•taint
tainted?•to_a•to_enum•to_s•to_yaml
to_yaml_properties•to_yaml_style•type•untaint

Implementing a proxy
class Proxy
instance_methods.each do |method|
undef_method method unless method =~ /^__/
end
puts name,args
end
end
Proxy.new.to_s

Unix was not designed to stop people
from doing stupid things, because that
would also stop them from doing
clever things.
—Doug Gwyn

Cultural
differences about
type
Java is very focused on the types of objects
Is the object an instance of a specific class?
Or does it implement a specific interface?
Ruby is focused on the behaviour
Does the object respond to a given message?

Types
public void foo( ArrayList list ) {
list.add("foo");
}
def foo list
list << 'foo'
end
What’s the type?
What’s the type?

Duck typing
def foo list
list << 'foo'
end
If list is a String
=> ‘foo’
If list is an Array
=> [‘foo’]
If list is an IO
=> string will be written to stream

Duck typing
Duck typing implies that an object is
interchangeable with any other object that
implements the same interface, regardless of
whether the objects have a related inheritance
hierarchy. -- Wikipedia
"If it walks like a duck and quacks like a duck,
it must be a duck." -- Pragmatic Dave Thomas

How does this
change how we
think of types?
think of types?
think of types?

Overflow conditions
int a = Integer.MAX_VALUE;
System.out.println(" a="+a);
System.out.println("a+1="+(a+1));
a=2147483647
a+1= ??

Overflow conditions
int a = Integer.MAX_VALUE;
System.out.println(" a="+a);
System.out.println("a+1="+(a+1));
a=2147483647
a+1=-2147483648
oops

Overflow in ruby?
number = 1000
1.upto(4) do
puts "#{number.class} #{number}"
number = number * number
end
Fixnum 1000
Fixnum 1000000
Bignum 1000000000000
Bignum 1000000000000000000000000

Closures
A closure is a function that is evaluated in an
environment containing one or more bound variables.
When called, the function can access these variables.
The explicit use of closures is associated with functional
programming and with languages such as ML and Lisp.
Constructs such as objects in other languages can also
be modeled with closures.
-- Wikipedia

Closures
A closure is a block of code that you can
manipulate and query
In Ruby we call them blocks or Procs
A block is a pure closure
A Proc is a block wrapped as an object
We generally use the terms block and Proc
interchangeably

Closures
multiplier = 5
block = lambda {|number| puts number * multiplier }
A block
An instance
of Proc
lambda() is a
method to convert
blocks into Procs

Closures
multiplier = 5
Parameter
to the block

Closures
multiplier = 5
Able to access variables
from outside the block

Proc’s
multiplier = 5
block.call 2
block.arity
prints 10
returns number of parameters
that the block takes. 1 in this case

Blocks as
parameters
multiplier = 5
1.upto(3) {|number| puts number * multiplier }
=> 5
=> 10
=> 15
Same block
as before
Called once for each time
through the loop

Alternate syntax
multiplier = 5
1.upto(3) {|number| puts number * multiplier }
1.upto(3) do |number|
puts number * multiplier
end
Equivalent

Why are closures
significant?
Presence of closures in a language completely
changes the design of the libraries
Closure based libraries generally result in
significantly less code

// Read the lines and split them into columns
List<String[]> lines= new ArrayList<String[]>();
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader("people.txt"));
String line = reader.readLine();
while( line != null ) {
lines.add( line.split("t") );
}
}
finally {
if( reader != null ) {
reader.close();
}
}
// then sort
Collections.sort(lines, new Comparator<String[]>() {
public int compare(String[] one, String[] two) {
return one[1].compareTo(two[1]);
}
});
// then write them back out
BufferedWriter writer = null;
try {
writer = new BufferedWriter( new FileWriter("people.txt") );
for( String[] strings : lines ) {
StringBuilder builder = new StringBuilder();
for( int i=0; i<strings.length; i++ ) {
if( i != 0 ) {
builder.append("t");
}
builder.append(strings[i]);
}
}
}
finally {
if( writer != null ) {
writer.close();
}
}
# Load the data
lines = Array.new
IO.foreach('people.txt') do |line|
lines << line.split
end
# Sort and write it back out
File.open('people.txt', 'w') do |file|
lines.sort {|a,b| a[1] <=> b[1]}.each do |array|
puts array.join("t")
end
end

Closure File
Example
file = File.new(fileName,'w')
begin
file.puts ‘some content’
rescue
file.close
end

Closure File
Example
begin
rescue
file.close
end Only one line of
business logic

Closure File
Example
begin
rescue
file.close
end
File.open(fileName,'w') do |file|
end

Ruby file IO
sample
# Load the data
lines = Array.new
IO.foreach('people.txt') do |line|
lines << line.split
end
# Sort and write it back out
File.open('people.txt', 'w') do |file|
lines.sort {|a,b| a[1] <=> b[1]}.each do |array|
puts array.join("t")
end
end

Closure-like things
in Java
final String name = getName();
new Thread( new Runnable() {
public void run() {
doSomething(name);
}
}).start();
Only one line of
business logic

Closures for
Java?
There are a couple of proposals being debated for
Java7
Unclear whether any of them will be accepted
In the past, Sun’s position has been that closures
didn’t make sense at this point in Java’s evolution
public static void main(String[] args) {
int plus2(int x) { return x+2; }
int(int) plus2b = plus2;
System.out.println(plus2b(2));
}

Inheriting
behaviour from
multiple places
C++ has multiple inheritance
Java has interfaces
Ruby has mixins

Mixins
Cannot be instantiated
Can be mixed in

Enumerable
class Foo
include Enumerable
def each &block
block.call 1
block.call 2
block.call 3
end
end
module Enumerable
def collect
array = []
each do |a|
array << yield(a)
end
array
end
end

Enumerable
Requires that the class implement each()
For max, min and sort the <=> operator is also
needed
Adds many methods for modifying, searching, sorting
the items
all?, any?, collect, detect, each_cons, each_slice,
each_with_index, entries, enum_cons, enum_slice,
enum_with_index, find, find_all, grep, include?,
inject, map, max, member?, min, partition, reject,
select, sort, sort_by, to_a, to_set, zip

Reopening classes
class Foo
def one
puts 'one'
end
end

Reopening classes
class Foo
def one
puts 'one'
end
end
class Foo
def two
puts 'two'
end
end
Reopening
the same class

Reopening classes
class Foo
def one
puts 'one'
end
end
class Foo
def one
puts '1'
end
end
Replacing, not
adding a method

Reopening core
classesclass String
def one
puts 'one'
end
end
We reopened
a CORE class
and modified it

Metaprogramming
Metaprogramming is the writing of computer
programs that write or manipulate other
programs (or themselves) as their data. In many
cases, this allows programmers to get more done
in the same amount of time as they would take to
write all the code manually.
-- Wikipedia

What changes can
we make at
runtime?
Anything we can hand code, we can
programmatically do
Because of late binding, EVERYTHING
happens at runtime

attr_accessor
class Foo
attr_accessor :bar
end
class Foo
def bar
@bar
end
def bar=(newBar)
@bar = newBar
end
end
Getter
Setter

class Foo
def self.attr_accessor name
module_eval <<-DONE
def #{name}()
@#{name}
end
def #{name}=(newValue)
@#{name} = newValue
end
DONE
end
my_attr_accessor :bar
end
Possible
implementation of
attr_accessor

class Foo
module_eval <<-DONE
def #{name}()
@#{name}
end
@#{name} = newValue
end
DONE
end
end
Possible
implementation of
attr_accessor
“Here Doc”
Evaluates to
String

class Foo
module_eval <<-DONE
def #{name}()
@#{name}
end
@#{name} = newValue
end
DONE
end
end
Possible
implementation of
attr_accessor
String
substitution

class Foo
module_eval <<-DONE
def #{name}()
@#{name}
end
@#{name} = newValue
end
DONE
end
end
Possible
implementation of
attr_accessor
Executes the string
in the context of
the class

Result
class Foo
def bar
@bar
end
def bar=(newBar)
@bar = newBar
end
end

ActiveRecord
class ListItem < ActiveRecord::Base
belongs_to :amazon_item
acts_as_taggable
acts_as_list :scope => :user
end

Date :: once
def once(*ids) # :nodoc:
for id in ids
module_eval <<-"end;", __FILE__, __LINE__
alias_method :__#{id.to_i}__, :#{id.to_s}
private :__#{id.to_i}__
def #{id.to_s}(*args, &block)
if defined? @__#{id.to_i}__
@__#{id.to_i}__
elsif ! self.frozen?
@__#{id.to_i}__ ||= __#{id.to_i}__(*args, &block)
else
__#{id.to_i}__(*args, &block)
end
end
end;
end
end

ObjectSpace
ObjectSpace.each_object do |o|
puts o
end
ObjectSpace.each_object(String) do |o|
puts o
end

ObjectSpace
ObjectSpace.each_object do |o|
puts o
end
ObjectSpace.each_object(String) do |o|
puts o
end
All objects
Only Strings

Continuations
A snapshot of the call stack that
the application can revert to at
some point in the future

Why
continuations?
To save the state of the application across
reboots of the VM
To save the state of the application across
requests to a web server
Seaside (smalltalk) does this today

Downsides
Only supported in one implementation of
Ruby
Will be removed from the language in Ruby
2.0

Implementations
Ruby 1.8.x - “reference implementation” in C
Ruby 1.9 - Next version of C interpreter
Rubinius - Ruby in Ruby (sort-of)
Cardinal - Ruby on Parrot
Iron Ruby - Ruby on the DLR (Microsoft)
Ruby.NET - Ruby on the CLR
JRuby - Ruby on the JVM (Sun)

JRuby
Runs on the Java Virtual Machine (JVM)
Full implementation of the Ruby language
Supported by Sun
Runs many benchmarks faster than the 1.8
reference implementation (written in C)
Able to easily call out to Java code

Ruby on Rails
Web application framework
Sweet spot - web application talking to a single
relational database
Allows very rapid development of web apps

Who’s using
rails?
Amazon • BBC • Cap Gemini
Chicago Tribune • Barclays • BPN • Cisco
CNET Electronic Arts • IBM • John Deere
JP Morgan Chase • LA Times • Limewire
Linked In • NASA • NBC • New York Times
Oakley • Oracle • Orbitz • Turner Media
twitter.com • Siemens • ThoughtWorks Yahoo!

JRuby on Rails?
Yes! You can run a rails application on JRuby
in a servlet container
Goldspike is the servlet that dispatches to rails
Tested on WebLogic, WebSphere, GlassFish,
Jetty, Tomcat
Warbler is the packaging tool that makes the
WAR
Supported on: WebLogic, WebSphere,
GlassFish, Jetty, Tomcat

Recap
Learning a new language will make you better
with all the languages you know
Ruby has a much more concise syntax which
means that it takes much less code to solve the
same problems
Ruby is able to run on the JVM which makes it an
option for shops with heavy investments in J2EE
infrastructure

Recap
Everything is an object
The language is extremely malleable
New classes/methods can be created on the
fly
Existing classes can be modified at any time

Contacting me
Mike Bowler
mbowler@GargoyleSoftware.com
www.GargoyleSoftware.com (company)
www.SphericalImprovement.com (blog)
Interested in learning more about how Ruby and
Java can coexist in your company? Just ask me.

Rubyforjavaprogrammers 1210167973516759-9

Recommended

More Related Content

What's hot (18)

Similar to Rubyforjavaprogrammers 1210167973516759-9 (20)

More from sagaroceanic11 (20)

Recently uploaded (20)

Rubyforjavaprogrammers 1210167973516759-9

Editor's Notes