General Purpose Language Ruby

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

2. Outline • Reference • Introduction • Ruby is • Features • Array • Loop • Ruby v.s. Java • Duck Typing • Dynamic Typing • Type Tag Checking • Functional Programming

3. Reference • Wikipedia http://en.wikipedia.org/wiki/Ruby_(programming_language) http://en.wikipedia.org/wiki/Comparison_of_programming_languages • Ruby Official Website http://www.ruby-lang.org/en/ • Learning Ruby http://www.math.umd.edu/~dcarrera/ruby/0.3/index.html • Duck Typing http://rubylearning.com/satishtalim/duck_typing.html

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

5. Ruby is • Cross-platform Operating System • Combines syntax by • Perl • Smalltalk-like OO features • Shares features with • Lisp • Python • Dylan • CLU

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

7. Ruby is • Obedient >> 'Hello World'                                                   => "Hello World” • >> 'blink ' * 4                                                          • => "blink blink blink blink "      • Your Calculator >> 1+1  => 2   Or >> 2**2**2                                                         => 16  

8. Features • Object-oriented • Four levels of variables: • Global $var • Instance @var • Local [a-z] or _; var • Constant [A-Z] • Exception handling • Iterators & closures • Automatic garbage collecting • Highly portable http://tryruby.hobix.com/

9. Array • >> numbers = ["zero", "one", "two", "three", "four"]    • => ["zero", "one", "two", "three", "four"]                       • => Array                                                                 • >> numbers[0]                                                            • => "zero"    What arrays do? •  >> numbers[0].class                                                 • => String   • >> numbers[0].upcase                                                • => "ZERO"  • >> numbers[0].reverse                                               • => "orez"                                                

10. Loop • If I knew Ruby when I was in grade school……. • >> 100.times do                                                        • .. puts "I won't do that again"                                    • .. end  • I won't do that again   • => 100 • My life was going to be much easier 

11. begin_time = Time.now.to_i i = 0 100.times do i += 1 j = 0 10.times do j += 1 k = 0 100.times do k += 1 puts i.to_s + " + " + j.to_s + " + " + k.to_s end end end end_time = Time.now.to_i difference = end_time - begin_time puts "It took " + difference.to_s + " seconds" ho = gets class test { publicstaticvoid 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- Syntax

12. Ruby v.s. Java • Performance • Ruby: 24 – 26 seconds • Java: 1 – 2 seconds

13. Duck Typing • Ruby interpreter is happy to treat it as it were a duck • If an object walks and talks like a duck • Duck typing means • An object type is defined by what it can do • Not by what it is • Duck typing refers to • less concerned with the class of an object • more concerned with what methods can be called on it • what operations can be performed

14. Duck Typing • we use respond_to? • Example • >> puts ('A string'.respond_to? :to_str)                                 • true                                                                     • => nil                                                                   • >> puts (Exception.new.respond_to? :to_str)                           • true                                                                     • => nil                                                                   • If an object quacks like a duck, just treat it as a duck…. • We should treat objects to the methods they define

15. >> class Duck                                          >> class Duck                                           .. def quack                                                             .. 'Quack!'                                                              .. end                                                                   .. def swim                                                              .. 'Paddle paddle paddle...'                                             .. end                                                                   .. end                                                                   => nil  >> class Goose                                                           .. def honk                                                              .. 'Honk!'                                                               .. end                                                                   .. def swim                                                              .. 'Splash splash splash...'                                             .. end                                                                   .. end                                                                   => nil                                                                   >> Duck Typing

16. >> class DuckRecording                                                  >> class DuckRecording                                                   .. def quack                                                             .. play                                                                  .. end                                                                   .. def play                                                              .. 'Quack'                                                               .. end                                                                   .. end                                                                   => 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         Duck Typing

17. Add methods to individual class instances class Duck def quack puts 'Quack!' end def swim puts 'Paddle paddle paddle...' end end d = Duck.new #create new instance of the class d.quack #call method d.swim #call method def d.walk #override existing method with #new functionality puts 'I am walking ... walking' end d.walk => nil => #<Duck:0x6cc7ddc> Quack! => nil Paddle paddle paddle... => nil => nil I am walking ... walking => nil irb(main):022:0> Add Method to Class Instances

18. Dynamic Typing • Ruby, the data types are not wholly declared on variable • Data associated with variables are not known until the time of execution • Advantage: • flexibility • Less work for the programmer

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

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

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

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

23. Why Ruby? • High productivity for programmers • Execution time is not the main concern • Web Developments • Projects like Ruby on Rails • Functional Programming • Paradigm treats computation as the evaluation of mathematical functions • Emphasize on application of functions • Largely being used in academia • Lambda calculus • Forms the foundation for most models of functional programming

24. Thank you !!