Ruby For Java Programmers

Ruby for Java Programmers

Mike Bowler

President, Gargoyle Software Inc.

Why learn another language?

Why Ruby?

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”

What influenced it?

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 binding

Early 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 unless if 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 arrays List<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<String> list = new ArrayList<String>(); list.add( "foo" ); list.add( "bar" ); list = Array.new list << 'foo' list << 'bar' list = [ 'foo' , 'bar' ]

%w() List<String> list = new ArrayList<String>(); list.add( "foo" ); list.add( "bar" ); list = Array.new list << 'foo' list << 'bar' list = [ 'foo' , '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 = [ 'foo' , '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 null Ruby’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

Message != Method

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 proxy class Proxy def method_missing name, *args, &proc puts name,args end end

Implementing a proxy class Proxy def method_missing name, *args, &proc 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 def method_missing name, *args, &proc 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 p rivate_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 def method_missing name, *args, &proc 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 block = lambda {|number| puts number * multiplier } Parameter to the block

Closures multiplier = 5 block = lambda {|number| puts number * multiplier } Able to access variables from outside the block

Proc’s multiplier = 5 block = lambda {|number| puts number * multiplier } 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( " " ) ); } } 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( " " ); } 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( " " ) end end

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

Closure File Example file = File. new (fileName, 'w' ) begin file.puts ‘some content’ rescue file.close end Only one line of business logic

Closure File Example file = File. new (fileName, 'w' ) begin file.puts ‘some content’ rescue file.close end File.open(fileName, 'w' ) do |file| file.puts ‘some content’ 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( " " ) 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

C++ : multiple inheritance

Java : inheritance

Ruby : 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 classes class 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

Possible implementation of attr_accessor 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 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 “ Here Doc” Evaluates to String

Possible implementation of attr_accessor 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 String substitution

Possible implementation of attr_accessor 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 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)

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?