Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-25T05:25:26Z

Vsuresw: /* See Also */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - [http://www.patternlanguage.com/leveltwo/ca.htm Christopher Alexander]

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A [http://en.wikipedia.org/wiki/Design_Patterns Design Pattern] is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in [http://en.wikipedia.org/wiki/Object-oriented_programming Object - Oriented Languages] help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A [http://www.oodesign.com/ Design Pattern] describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the [http://www.oodesign.com/singleton-pattern.html Singleton patterns][http://en.wikipedia.org/wiki/Singleton_pattern (Wiki)]. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class. 
[http://c2.com/cgi/wiki?SingletonPattern Here ] is more to read on Singleton patterns.

==Adapter Pattern==

An [http://www.oodesign.com/adapter-pattern.html Adapter pattern][http://en.wikipedia.org/wiki/Adapter_pattern (Wiki) ], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'. 
[http://c2.com/cgi/wiki?AdapterPattern This one ] is a good read on Adapter patterns and also contains links to other articles about Adapter Pattern.

==Closures and Patterns==

Patterns can be implemented using Closures. A [http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch3_3a_av#Closures Closure] can be described as a block of code ith the properties mentioned below:

* The block of code can be passed around like a value.
* Any procedure or method that has the value can execute it.
* A Closure can refer to the variables from the context in which it was created.

The Command Design Pattern and Strategy Design Patterns are examples of this.

==Command Pattern==

The design patterns we saw above deal with classes and work around the way classes and objects are manipulated, interpreted, created etc. Actually, the adapter pattern bases its necessity on the need for 'code reuse'. But, it can only implement code reuse at a class or method level. What if we need a more finer to do it.For example, Sometimes one might need to store bunch of code to be used by a peer or himself at a later point. This bunch of code is not associated with any class, or any method.
 

[http://en.wikipedia.org/wiki/Command_pattern Command Patterns] lends itself to our use at this point. With command pattern it is possible to store a piece of code or a set of commands to be executed at a later stage. And of course, this is implemented with the use of procs in Ruby.

 
This is how command pattern is usually implemented. We have a class which holds the commands as a [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Object]. And whenever it is to be called, 'call' is used to execute that proc.

class Command
def initialize(input)
@local_proc = input
end

def return_proc
@local_proc
end
end

Now we have a class that stores a command. Now let us create a 'command'.

myProc = proc{ puts 8 }

Now we have a proc object that we want to use.

obj = Command.new(myProc)
obj.return_proc.call
8

Then we create an object storing myProc inside it. Then we use the object to return the proc and use 'call' on it to execute it. One could also create an array of commands by simply creating an array of Command objects and storing the proc in them. 

One important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The [http://en.wikipedia.org/wiki/Strategy_pattern Strategy Pattern] helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Objects]. Below is an example of the Strategy Pattern which deals with areas of geometric shapes:

class findArea
attr_accessor :strategy
def calArea(x,y)
strategy.call(*args)
end
def area_square … end
def area_rect … end
end

Here, we have a class findArea, which calculates the area of the given geometric shape by invoking the methods area_square or area_rect based upon whether the given figure is a square or rectangle.

sides = findArea.new
if x == y
puts "The given object is a square"
sides.strategy = findArea.method(:area_square)
else
puts "The given object is a rectangle"
sides.strategy = findArea.method(:area_rect)
end
sides.calArea(x,y)

Here, the path or strategy chosen is based on an if condition involving the values of x and y which are not known until runtime. Therefore, the algorithm that will be made use of to calculate the area, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==See Also==

[http://www.oodesign.com 1. Object Oriented Design]

[http://en.wikipedia.org/wiki/Object-oriented_programming 2. Object - Oriented Programming]

[http://c2c.com 3. More Object oriented Programming]

==References==

[http://designpatternsinruby.com/section01/article.html 1. Article on Design Patterns in Ruby]

[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf 2. Design Patterns - Elements of Reusable Object Oriented Software by Erich Gamma]

[http://en.wikipedia.org/wiki/Singleton_pattern 3. Wiki - Singleton Pattern]

[http://en.wikipedia.org/wiki/Adapter_pattern 4. Wiki - Adapter Pattern]

[http://en.wikipedia.org/wiki/Command_pattern 5. Wiki - Command Pattern]

[http://en.wikipedia.org/wiki/Strategy_pattern 6. Wiki - Strategy Pattern]

[http://en.wikipedia.org/wiki/Closure_(computer_science) 7. Wiki - Closures]

[http://courses.ncsu.edu/csc517//common/lectures/notes/lec13.pdf 8. Lec 13 - Class Notes]

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-25T05:21:32Z

Vsuresw: /* Closures and Patterns */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - [http://www.patternlanguage.com/leveltwo/ca.htm Christopher Alexander]

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A [http://en.wikipedia.org/wiki/Design_Patterns Design Pattern] is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in [http://en.wikipedia.org/wiki/Object-oriented_programming Object - Oriented Languages] help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A [http://www.oodesign.com/ Design Pattern] describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the [http://www.oodesign.com/singleton-pattern.html Singleton patterns][http://en.wikipedia.org/wiki/Singleton_pattern (Wiki)]. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class. 
[http://c2.com/cgi/wiki?SingletonPattern Here ] is more to read on Singleton patterns.

==Adapter Pattern==

An [http://www.oodesign.com/adapter-pattern.html Adapter pattern][http://en.wikipedia.org/wiki/Adapter_pattern (Wiki) ], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'. 
[http://c2.com/cgi/wiki?AdapterPattern This one ] is a good read on Adapter patterns and also contains links to other articles about Adapter Pattern.

==Closures and Patterns==

Patterns can be implemented using Closures. A [http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch3_3a_av#Closures Closure] can be described as a block of code ith the properties mentioned below:

* The block of code can be passed around like a value.
* Any procedure or method that has the value can execute it.
* A Closure can refer to the variables from the context in which it was created.

The Command Design Pattern and Strategy Design Patterns are examples of this.

==Command Pattern==

The design patterns we saw above deal with classes and work around the way classes and objects are manipulated, interpreted, created etc. Actually, the adapter pattern bases its necessity on the need for 'code reuse'. But, it can only implement code reuse at a class or method level. What if we need a more finer to do it.For example, Sometimes one might need to store bunch of code to be used by a peer or himself at a later point. This bunch of code is not associated with any class, or any method.
 

[http://en.wikipedia.org/wiki/Command_pattern Command Patterns] lends itself to our use at this point. With command pattern it is possible to store a piece of code or a set of commands to be executed at a later stage. And of course, this is implemented with the use of procs in Ruby.

 
This is how command pattern is usually implemented. We have a class which holds the commands as a [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Object]. And whenever it is to be called, 'call' is used to execute that proc.

class Command
def initialize(input)
@local_proc = input
end

def return_proc
@local_proc
end
end

Now we have a class that stores a command. Now let us create a 'command'.

myProc = proc{ puts 8 }

Now we have a proc object that we want to use.

obj = Command.new(myProc)
obj.return_proc.call
8

Then we create an object storing myProc inside it. Then we use the object to return the proc and use 'call' on it to execute it. One could also create an array of commands by simply creating an array of Command objects and storing the proc in them. 

One important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The [http://en.wikipedia.org/wiki/Strategy_pattern Strategy Pattern] helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Objects]. Below is an example of the Strategy Pattern which deals with areas of geometric shapes:

class findArea
attr_accessor :strategy
def calArea(x,y)
strategy.call(*args)
end
def area_square … end
def area_rect … end
end

Here, we have a class findArea, which calculates the area of the given geometric shape by invoking the methods area_square or area_rect based upon whether the given figure is a square or rectangle.

sides = findArea.new
if x == y
puts "The given object is a square"
sides.strategy = findArea.method(:area_square)
else
puts "The given object is a rectangle"
sides.strategy = findArea.method(:area_rect)
end
sides.calArea(x,y)

Here, the path or strategy chosen is based on an if condition involving the values of x and y which are not known until runtime. Therefore, the algorithm that will be made use of to calculate the area, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==See Also==

[http://www.oodesign.com 1. Object Oriented Design]

[http://en.wikipedia.org/wiki/Object-oriented_programming 2. Object - Oriented Programming]

==References==

[http://designpatternsinruby.com/section01/article.html 1. Article on Design Patterns in Ruby]

[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf 2. Design Patterns - Elements of Reusable Object Oriented Software by Erich Gamma]

[http://en.wikipedia.org/wiki/Singleton_pattern 3. Wiki - Singleton Pattern]

[http://en.wikipedia.org/wiki/Adapter_pattern 4. Wiki - Adapter Pattern]

[http://en.wikipedia.org/wiki/Command_pattern 5. Wiki - Command Pattern]

[http://en.wikipedia.org/wiki/Strategy_pattern 6. Wiki - Strategy Pattern]

[http://en.wikipedia.org/wiki/Closure_(computer_science) 7. Wiki - Closures]

[http://courses.ncsu.edu/csc517//common/lectures/notes/lec13.pdf 8. Lec 13 - Class Notes]

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-25T05:21:14Z

Vsuresw: /* Closures and Patterns */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - [http://www.patternlanguage.com/leveltwo/ca.htm Christopher Alexander]

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A [http://en.wikipedia.org/wiki/Design_Patterns Design Pattern] is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in [http://en.wikipedia.org/wiki/Object-oriented_programming Object - Oriented Languages] help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A [http://www.oodesign.com/ Design Pattern] describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the [http://www.oodesign.com/singleton-pattern.html Singleton patterns][http://en.wikipedia.org/wiki/Singleton_pattern (Wiki)]. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class. 
[http://c2.com/cgi/wiki?SingletonPattern Here ] is more to read on Singleton patterns.

==Adapter Pattern==

An [http://www.oodesign.com/adapter-pattern.html Adapter pattern][http://en.wikipedia.org/wiki/Adapter_pattern (Wiki) ], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'. 
[http://c2.com/cgi/wiki?AdapterPattern This one ] is a good read on Adapter patterns and also contains links to other articles about Adapter Pattern.

==Closures and Patterns==

Patterns can be implemented using Closures. A http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch3_3a_av#Closures Closure] can be described as a block of code ith the properties mentioned below:

* The block of code can be passed around like a value.
* Any procedure or method that has the value can execute it.
* A Closure can refer to the variables from the context in which it was created.

The Command Design Pattern and Strategy Design Patterns are examples of this.

==Command Pattern==

The design patterns we saw above deal with classes and work around the way classes and objects are manipulated, interpreted, created etc. Actually, the adapter pattern bases its necessity on the need for 'code reuse'. But, it can only implement code reuse at a class or method level. What if we need a more finer to do it.For example, Sometimes one might need to store bunch of code to be used by a peer or himself at a later point. This bunch of code is not associated with any class, or any method.
 

[http://en.wikipedia.org/wiki/Command_pattern Command Patterns] lends itself to our use at this point. With command pattern it is possible to store a piece of code or a set of commands to be executed at a later stage. And of course, this is implemented with the use of procs in Ruby.

 
This is how command pattern is usually implemented. We have a class which holds the commands as a [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Object]. And whenever it is to be called, 'call' is used to execute that proc.

class Command
def initialize(input)
@local_proc = input
end

def return_proc
@local_proc
end
end

Now we have a class that stores a command. Now let us create a 'command'.

myProc = proc{ puts 8 }

Now we have a proc object that we want to use.

obj = Command.new(myProc)
obj.return_proc.call
8

Then we create an object storing myProc inside it. Then we use the object to return the proc and use 'call' on it to execute it. One could also create an array of commands by simply creating an array of Command objects and storing the proc in them. 

One important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The [http://en.wikipedia.org/wiki/Strategy_pattern Strategy Pattern] helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Objects]. Below is an example of the Strategy Pattern which deals with areas of geometric shapes:

class findArea
attr_accessor :strategy
def calArea(x,y)
strategy.call(*args)
end
def area_square … end
def area_rect … end
end

Here, we have a class findArea, which calculates the area of the given geometric shape by invoking the methods area_square or area_rect based upon whether the given figure is a square or rectangle.

sides = findArea.new
if x == y
puts "The given object is a square"
sides.strategy = findArea.method(:area_square)
else
puts "The given object is a rectangle"
sides.strategy = findArea.method(:area_rect)
end
sides.calArea(x,y)

Here, the path or strategy chosen is based on an if condition involving the values of x and y which are not known until runtime. Therefore, the algorithm that will be made use of to calculate the area, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==See Also==

[http://www.oodesign.com 1. Object Oriented Design]

[http://en.wikipedia.org/wiki/Object-oriented_programming 2. Object - Oriented Programming]

==References==

[http://designpatternsinruby.com/section01/article.html 1. Article on Design Patterns in Ruby]

[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf 2. Design Patterns - Elements of Reusable Object Oriented Software by Erich Gamma]

[http://en.wikipedia.org/wiki/Singleton_pattern 3. Wiki - Singleton Pattern]

[http://en.wikipedia.org/wiki/Adapter_pattern 4. Wiki - Adapter Pattern]

[http://en.wikipedia.org/wiki/Command_pattern 5. Wiki - Command Pattern]

[http://en.wikipedia.org/wiki/Strategy_pattern 6. Wiki - Strategy Pattern]

[http://en.wikipedia.org/wiki/Closure_(computer_science) 7. Wiki - Closures]

[http://courses.ncsu.edu/csc517//common/lectures/notes/lec13.pdf 8. Lec 13 - Class Notes]

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-25T05:17:17Z

Vsuresw: /* Adapter Pattern */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - [http://www.patternlanguage.com/leveltwo/ca.htm Christopher Alexander]

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A [http://en.wikipedia.org/wiki/Design_Patterns Design Pattern] is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in [http://en.wikipedia.org/wiki/Object-oriented_programming Object - Oriented Languages] help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A [http://www.oodesign.com/ Design Pattern] describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the [http://www.oodesign.com/singleton-pattern.html Singleton patterns][http://en.wikipedia.org/wiki/Singleton_pattern (Wiki)]. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class. 
[http://c2.com/cgi/wiki?SingletonPattern Here ] is more to read on Singleton patterns.

==Adapter Pattern==

An [http://www.oodesign.com/adapter-pattern.html Adapter pattern][http://en.wikipedia.org/wiki/Adapter_pattern (Wiki) ], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'. 
[http://c2.com/cgi/wiki?AdapterPattern This one ] is a good read on Adapter patterns and also contains links to other articles about Adapter Pattern.

==Closures and Patterns==

Patterns can be implemented using Closures. A [http://en.wikipedia.org/wiki/Closure_(computer_science) Closure] can be described as a block of code ith the properties mentioned below:

* The block of code can be passed around like a value.
* Any procedure or method that has the value can execute it.
* A Closure can refer to the variables from the context in which it was created.

The Command Design Pattern and Strategy Design Patterns are examples of this.

==Command Pattern==

The design patterns we saw above deal with classes and work around the way classes and objects are manipulated, interpreted, created etc. Actually, the adapter pattern bases its necessity on the need for 'code reuse'. But, it can only implement code reuse at a class or method level. What if we need a more finer to do it.For example, Sometimes one might need to store bunch of code to be used by a peer or himself at a later point. This bunch of code is not associated with any class, or any method.
 

[http://en.wikipedia.org/wiki/Command_pattern Command Patterns] lends itself to our use at this point. With command pattern it is possible to store a piece of code or a set of commands to be executed at a later stage. And of course, this is implemented with the use of procs in Ruby.

 
This is how command pattern is usually implemented. We have a class which holds the commands as a [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Object]. And whenever it is to be called, 'call' is used to execute that proc.

class Command
def initialize(input)
@local_proc = input
end

def return_proc
@local_proc
end
end

Now we have a class that stores a command. Now let us create a 'command'.

myProc = proc{ puts 8 }

Now we have a proc object that we want to use.

obj = Command.new(myProc)
obj.return_proc.call
8

Then we create an object storing myProc inside it. Then we use the object to return the proc and use 'call' on it to execute it. One could also create an array of commands by simply creating an array of Command objects and storing the proc in them. 

One important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The [http://en.wikipedia.org/wiki/Strategy_pattern Strategy Pattern] helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Objects]. Below is an example of the Strategy Pattern which deals with areas of geometric shapes:

class findArea
attr_accessor :strategy
def calArea(x,y)
strategy.call(*args)
end
def area_square … end
def area_rect … end
end

Here, we have a class findArea, which calculates the area of the given geometric shape by invoking the methods area_square or area_rect based upon whether the given figure is a square or rectangle.

sides = findArea.new
if x == y
puts "The given object is a square"
sides.strategy = findArea.method(:area_square)
else
puts "The given object is a rectangle"
sides.strategy = findArea.method(:area_rect)
end
sides.calArea(x,y)

Here, the path or strategy chosen is based on an if condition involving the values of x and y which are not known until runtime. Therefore, the algorithm that will be made use of to calculate the area, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==See Also==

[http://www.oodesign.com 1. Object Oriented Design]

[http://en.wikipedia.org/wiki/Object-oriented_programming 2. Object - Oriented Programming]

==References==

[http://designpatternsinruby.com/section01/article.html 1. Article on Design Patterns in Ruby]

[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf 2. Design Patterns - Elements of Reusable Object Oriented Software by Erich Gamma]

[http://en.wikipedia.org/wiki/Singleton_pattern 3. Wiki - Singleton Pattern]

[http://en.wikipedia.org/wiki/Adapter_pattern 4. Wiki - Adapter Pattern]

[http://en.wikipedia.org/wiki/Command_pattern 5. Wiki - Command Pattern]

[http://en.wikipedia.org/wiki/Strategy_pattern 6. Wiki - Strategy Pattern]

[http://en.wikipedia.org/wiki/Closure_(computer_science) 7. Wiki - Closures]

[http://courses.ncsu.edu/csc517//common/lectures/notes/lec13.pdf 8. Lec 13 - Class Notes]

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-25T05:15:21Z

Vsuresw: /* Singleton Pattern */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - [http://www.patternlanguage.com/leveltwo/ca.htm Christopher Alexander]

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A [http://en.wikipedia.org/wiki/Design_Patterns Design Pattern] is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in [http://en.wikipedia.org/wiki/Object-oriented_programming Object - Oriented Languages] help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A [http://www.oodesign.com/ Design Pattern] describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the [http://www.oodesign.com/singleton-pattern.html Singleton patterns][http://en.wikipedia.org/wiki/Singleton_pattern (Wiki)]. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class. 
[http://c2.com/cgi/wiki?SingletonPattern Here ] is more to read on Singleton patterns.

==Adapter Pattern==

An [http://www.oodesign.com/adapter-pattern.html Adapter pattern][http://en.wikipedia.org/wiki/Adapter_pattern (Wiki) ], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'.

==Closures and Patterns==

Patterns can be implemented using Closures. A [http://en.wikipedia.org/wiki/Closure_(computer_science) Closure] can be described as a block of code ith the properties mentioned below:

* The block of code can be passed around like a value.
* Any procedure or method that has the value can execute it.
* A Closure can refer to the variables from the context in which it was created.

The Command Design Pattern and Strategy Design Patterns are examples of this.

==Command Pattern==

The design patterns we saw above deal with classes and work around the way classes and objects are manipulated, interpreted, created etc. Actually, the adapter pattern bases its necessity on the need for 'code reuse'. But, it can only implement code reuse at a class or method level. What if we need a more finer to do it.For example, Sometimes one might need to store bunch of code to be used by a peer or himself at a later point. This bunch of code is not associated with any class, or any method.
 

[http://en.wikipedia.org/wiki/Command_pattern Command Patterns] lends itself to our use at this point. With command pattern it is possible to store a piece of code or a set of commands to be executed at a later stage. And of course, this is implemented with the use of procs in Ruby.

 
This is how command pattern is usually implemented. We have a class which holds the commands as a [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Object]. And whenever it is to be called, 'call' is used to execute that proc.

class Command
def initialize(input)
@local_proc = input
end

def return_proc
@local_proc
end
end

Now we have a class that stores a command. Now let us create a 'command'.

myProc = proc{ puts 8 }

Now we have a proc object that we want to use.

obj = Command.new(myProc)
obj.return_proc.call
8

Then we create an object storing myProc inside it. Then we use the object to return the proc and use 'call' on it to execute it. One could also create an array of commands by simply creating an array of Command objects and storing the proc in them. 

One important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The [http://en.wikipedia.org/wiki/Strategy_pattern Strategy Pattern] helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Objects]. Below is an example of the Strategy Pattern which deals with areas of geometric shapes:

class findArea
attr_accessor :strategy
def calArea(x,y)
strategy.call(*args)
end
def area_square … end
def area_rect … end
end

Here, we have a class findArea, which calculates the area of the given geometric shape by invoking the methods area_square or area_rect based upon whether the given figure is a square or rectangle.

sides = findArea.new
if x == y
puts "The given object is a square"
sides.strategy = findArea.method(:area_square)
else
puts "The given object is a rectangle"
sides.strategy = findArea.method(:area_rect)
end
sides.calArea(x,y)

Here, the path or strategy chosen is based on an if condition involving the values of x and y which are not known until runtime. Therefore, the algorithm that will be made use of to calculate the area, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==See Also==

[http://www.oodesign.com 1. Object Oriented Design]

[http://en.wikipedia.org/wiki/Object-oriented_programming 2. Object - Oriented Programming]

==References==

[http://designpatternsinruby.com/section01/article.html 1. Article on Design Patterns in Ruby]

[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf 2. Design Patterns - Elements of Reusable Object Oriented Software by Erich Gamma]

[http://en.wikipedia.org/wiki/Singleton_pattern 3. Wiki - Singleton Pattern]

[http://en.wikipedia.org/wiki/Adapter_pattern 4. Wiki - Adapter Pattern]

[http://en.wikipedia.org/wiki/Command_pattern 5. Wiki - Command Pattern]

[http://en.wikipedia.org/wiki/Strategy_pattern 6. Wiki - Strategy Pattern]

[http://en.wikipedia.org/wiki/Closure_(computer_science) 7. Wiki - Closures]

[http://courses.ncsu.edu/csc517//common/lectures/notes/lec13.pdf 8. Lec 13 - Class Notes]

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-25T04:38:22Z

Vsuresw: /* Adapter Pattern */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - [http://www.patternlanguage.com/leveltwo/ca.htm Christopher Alexander]

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A [http://en.wikipedia.org/wiki/Design_Patterns Design Pattern] is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in [http://en.wikipedia.org/wiki/Object-oriented_programming Object - Oriented Languages] help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A [http://www.oodesign.com/ Design Pattern] describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the [http://www.oodesign.com/singleton-pattern.html Singleton patterns][http://en.wikipedia.org/wiki/Singleton_pattern (Wiki)]. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class.

==Adapter Pattern==

An [http://www.oodesign.com/adapter-pattern.html Adapter pattern][http://en.wikipedia.org/wiki/Adapter_pattern (Wiki) ], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'.

==Closures and Patterns==

Patterns can be implemented using Closures. A [http://en.wikipedia.org/wiki/Closure_(computer_science) Closure] can be described as a block of code ith the properties mentioned below:

* The block of code can be passed around like a value.
* Any procedure or method that has the value can execute it.
* A Closure can refer to the variables from the context in which it was created.

The Command Design Pattern and Strategy Design Patterns are examples of this.

==Command Pattern==

The design patterns we saw above deal with classes and work around the way classes and objects are manipulated, interpreted, created etc. Actually, the adapter pattern bases its necessity on the need for 'code reuse'. But, it can only implement code reuse at a class or method level. What if we need a more finer to do it.For example, Sometimes one might need to store bunch of code to be used by a peer or himself at a later point. This bunch of code is not associated with any class, or any method.
 

[http://en.wikipedia.org/wiki/Command_pattern Command Patterns] lends itself to our use at this point. With command pattern it is possible to store a piece of code or a set of commands to be executed at a later stage. And of course, this is implemented with the use of procs in Ruby.

 
This is how command pattern is usually implemented. We have a class which holds the commands as a [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Object]. And whenever it is to be called, 'call' is used to execute that proc.

class Command
def initialize(input)
@local_proc = input
end

def return_proc
@local_proc
end
end

Now we have a class that stores a command. Now let us create a 'command'.

myProc = proc{ puts 8 }

Now we have a proc object that we want to use.

obj = Command.new(myProc)
obj.return_proc.call
8

Then we create an object storing myProc inside it. Then we use the object to return the proc and use 'call' on it to execute it. One could also create an array of commands by simply creating an array of Command objects and storing the proc in them. 

One important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The [http://en.wikipedia.org/wiki/Strategy_pattern Strategy Pattern] helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Objects]. Below is an example of the Strategy Pattern which deals with areas of geometric shapes:

class findArea
attr_accessor :strategy
def calArea(x,y)
strategy.call(*args)
end
def area_square … end
def area_rect … end
end

Here, we have a class findArea, which calculates the area of the given geometric shape by invoking the methods area_square or area_rect based upon whether the given figure is a square or rectangle.

sides = findArea.new
if x == y
puts "The given object is a square"
sides.strategy = findArea.method(:area_square)
else
puts "The given object is a rectangle"
sides.strategy = findArea.method(:area_rect)
end
sides.calArea(x,y)

Here, the path or strategy chosen is based on an if condition involving the values of x and y which are not known until runtime. Therefore, the algorithm that will be made use of to calculate the area, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==See Also==

[http://www.oodesign.com 1. Object Oriented Design]

[http://en.wikipedia.org/wiki/Object-oriented_programming 2. Object - Oriented Programming]

==References==

[http://designpatternsinruby.com/section01/article.html 1. Article on Design Patterns in Ruby]

[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf 2. Design Patterns - Elements of Reusable Object Oriented Software by Erich Gamma]

[http://en.wikipedia.org/wiki/Singleton_pattern 3. Wiki - Singleton Pattern]

[http://en.wikipedia.org/wiki/Adapter_pattern 4. Wiki - Adapter Pattern]

[http://en.wikipedia.org/wiki/Command_pattern 5. Wiki - Command Pattern]

[http://en.wikipedia.org/wiki/Strategy_pattern 6. Wiki - Strategy Pattern]

[http://en.wikipedia.org/wiki/Closure_(computer_science) 7. Wiki - Closures]

[http://courses.ncsu.edu/csc517//common/lectures/notes/lec13.pdf 8. Lec 13 - Class Notes]

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-25T04:36:46Z

Vsuresw: /* Singleton Pattern */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - [http://www.patternlanguage.com/leveltwo/ca.htm Christopher Alexander]

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A [http://en.wikipedia.org/wiki/Design_Patterns Design Pattern] is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in [http://en.wikipedia.org/wiki/Object-oriented_programming Object - Oriented Languages] help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A [http://www.oodesign.com/ Design Pattern] describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the [http://www.oodesign.com/singleton-pattern.html Singleton patterns][http://en.wikipedia.org/wiki/Singleton_pattern (Wiki)]. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class.

==Adapter Pattern==

An [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Design Pattern], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'.

==Closures and Patterns==

Patterns can be implemented using Closures. A [http://en.wikipedia.org/wiki/Closure_(computer_science) Closure] can be described as a block of code ith the properties mentioned below:

* The block of code can be passed around like a value.
* Any procedure or method that has the value can execute it.
* A Closure can refer to the variables from the context in which it was created.

The Command Design Pattern and Strategy Design Patterns are examples of this.

==Command Pattern==

The design patterns we saw above deal with classes and work around the way classes and objects are manipulated, interpreted, created etc. Actually, the adapter pattern bases its necessity on the need for 'code reuse'. But, it can only implement code reuse at a class or method level. What if we need a more finer to do it.For example, Sometimes one might need to store bunch of code to be used by a peer or himself at a later point. This bunch of code is not associated with any class, or any method.
 

[http://en.wikipedia.org/wiki/Command_pattern Command Patterns] lends itself to our use at this point. With command pattern it is possible to store a piece of code or a set of commands to be executed at a later stage. And of course, this is implemented with the use of procs in Ruby.

 
This is how command pattern is usually implemented. We have a class which holds the commands as a [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Object]. And whenever it is to be called, 'call' is used to execute that proc.

class Command
def initialize(input)
@local_proc = input
end

def return_proc
@local_proc
end
end

Now we have a class that stores a command. Now let us create a 'command'.

myProc = proc{ puts 8 }

Now we have a proc object that we want to use.

obj = Command.new(myProc)
obj.return_proc.call
8

Then we create an object storing myProc inside it. Then we use the object to return the proc and use 'call' on it to execute it. One could also create an array of commands by simply creating an array of Command objects and storing the proc in them. 

One important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The [http://en.wikipedia.org/wiki/Strategy_pattern Strategy Pattern] helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Objects]. Below is an example of the Strategy Pattern which deals with areas of geometric shapes:

class findArea
attr_accessor :strategy
def calArea(x,y)
strategy.call(*args)
end
def area_square … end
def area_rect … end
end

Here, we have a class findArea, which calculates the area of the given geometric shape by invoking the methods area_square or area_rect based upon whether the given figure is a square or rectangle.

sides = findArea.new
if x == y
puts "The given object is a square"
sides.strategy = findArea.method(:area_square)
else
puts "The given object is a rectangle"
sides.strategy = findArea.method(:area_rect)
end
sides.calArea(x,y)

Here, the path or strategy chosen is based on an if condition involving the values of x and y which are not known until runtime. Therefore, the algorithm that will be made use of to calculate the area, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==See Also==

[http://www.oodesign.com 1. Object Oriented Design]

[http://en.wikipedia.org/wiki/Object-oriented_programming 2. Object - Oriented Programming]

==References==

[http://designpatternsinruby.com/section01/article.html 1. Article on Design Patterns in Ruby]

[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf 2. Design Patterns - Elements of Reusable Object Oriented Software by Erich Gamma]

[http://en.wikipedia.org/wiki/Singleton_pattern 3. Wiki - Singleton Pattern]

[http://en.wikipedia.org/wiki/Adapter_pattern 4. Wiki - Adapter Pattern]

[http://en.wikipedia.org/wiki/Command_pattern 5. Wiki - Command Pattern]

[http://en.wikipedia.org/wiki/Strategy_pattern 6. Wiki - Strategy Pattern]

[http://en.wikipedia.org/wiki/Closure_(computer_science) 7. Wiki - Closures]

[http://courses.ncsu.edu/csc517//common/lectures/notes/lec13.pdf 8. Lec 13 - Class Notes]

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-25T04:18:43Z

Vsuresw: /* Adapter Pattern */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - [http://www.patternlanguage.com/leveltwo/ca.htm Christopher Alexander]

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A [http://en.wikipedia.org/wiki/Design_Patterns Design Pattern] is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in [http://en.wikipedia.org/wiki/Object-oriented_programming Object - Oriented Languages] help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A [http://www.oodesign.com/ Design Pattern] describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the [http://en.wikipedia.org/wiki/Singleton_pattern Singleton pattern]. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class.

==Adapter Pattern==

An [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Design Pattern], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'.

==Closures and Patterns==

Patterns can be implemented using Closures. A [http://en.wikipedia.org/wiki/Closure_(computer_science) Closure] can be described as a block of code ith the properties mentioned below:

* The block of code can be passed around like a value.
* Any procedure or method that has the value can execute it.
* A Closure can refer to the variables from the context in which it was created.

The Command Design Pattern and Strategy Design Patterns are examples of this.

==Command Pattern==

The design patterns we saw above deal with classes and work around the way classes and objects are manipulated, interpreted, created etc. Actually, the adapter pattern bases its necessity on the need for 'code reuse'. But, it can only implement code reuse at a class or method level. What if we need a more finer to do it.For example, Sometimes one might need to store bunch of code to be used by a peer or himself at a later point. This bunch of code is not associated with any class, or any method.
 

[http://en.wikipedia.org/wiki/Command_pattern Command Patterns] lends itself to our use at this point. With command pattern it is possible to store a piece of code or a set of commands to be executed at a later stage. And of course, this is implemented with the use of procs in Ruby.

 
This is how command pattern is usually implemented. We have a class which holds the commands as a [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Object]. And whenever it is to be called, 'call' is used to execute that proc.

class Command
def initialize(input)
@local_proc = input
end

def return_proc
@local_proc
end
end

Now we have a class that stores a command. Now let us create a 'command'.

myProc = proc{ puts 8 }

Now we have a proc object that we want to use.

obj = Command.new(myProc)
obj.return_proc.call
8

Then we create an object storing myProc inside it. Then we use the object to return the proc and use 'call' on it to execute it. One could also create an array of commands by simply creating an array of Command objects and storing the proc in them. 

One important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The [http://en.wikipedia.org/wiki/Strategy_pattern Strategy Pattern] helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using [http://www.ruby-doc.org/core-1.9.2/Proc.html Proc Objects]. Below is an example of the Strategy Pattern which deals with areas of geometric shapes:

class findArea
attr_accessor :strategy
def calArea(x,y)
strategy.call(*args)
end
def area_square … end
def area_rect … end
end

Here, we have a class findArea, which calculates the area of the given geometric shape by invoking the methods area_square or area_rect based upon whether the given figure is a square or rectangle.

sides = findArea.new
if x == y
puts "The given object is a square"
sides.strategy = findArea.method(:area_square)
else
puts "The given object is a rectangle"
sides.strategy = findArea.method(:area_rect)
end
sides.calArea(x,y)

Here, the path or strategy chosen is based on an if condition involving the values of x and y which are not known until runtime. Therefore, the algorithm that will be made use of to calculate the area, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==See Also==

[http://www.oodesign.com 1. Object Oriented Design]

[http://en.wikipedia.org/wiki/Object-oriented_programming 2. Object - Oriented Programming]

==References==

[http://designpatternsinruby.com/section01/article.html 1. Article on Design Patterns in Ruby]

[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf 2. Design Patterns - Elements of Reusable Object Oriented Software by Erich Gamma]

[http://en.wikipedia.org/wiki/Singleton_pattern 3. Wiki - Singleton Pattern]

[http://en.wikipedia.org/wiki/Adapter_pattern 4. Wiki - Adapter Pattern]

[http://en.wikipedia.org/wiki/Command_pattern 5. Wiki - Command Pattern]

[http://en.wikipedia.org/wiki/Strategy_pattern 6. Wiki - Strategy Pattern]

[http://en.wikipedia.org/wiki/Closure_(computer_science) 7. Wiki - Closures]

[http://courses.ncsu.edu/csc517//common/lectures/notes/lec13.pdf 8. Lec 13 - Class Notes]

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-20T20:45:07Z

Vsuresw: /* Command Pattern */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - '''Christopher Alexander'''

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A Design Pattern is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in Object - Oriented Languages help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A Design Pattern describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Observer Design Pattern''''', which defines a one - to - many dependency among objects such that, the change in state of an object causes all its dependents to be notified and updated automatically.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the Singleton pattern. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class.

==Adapter Pattern==

An [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Design Pattern], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'.

==Observer Pattern==

The Observer Pattern, also known as the Dependents or Publish - Subscribe Pattern, defines a one-to-many dependency between objects such that the change in state of an object causes the dependent objects to be notified and updated automatically.

Partitioning of an application into a collection of co-operating classes, would require consistency to be maintained among these classes.

==Command Pattern==

The design patterns we saw above deal with classes and work around the way classes and objects are manipulated, interpreted, created etc. Actually, the adapter pattern bases its necessity on the need for 'code reuse'. But, it can only implement code reuse at a class or method level. What if we need a more finer to do it.For example, Sometimes one might need to store bunch of code to be used by a peer or himself at a later point. This bunch of code is not associated with any class, or any method.
 
Command patterns lends itself to our use at this point. With command pattern it is possible to store a piece of code or a set of commands to be executed at a later stage. And of course, this is implemented with the use of procs in Ruby.
 
This is how command pattern is usually implemented. We have a class which holds the commands as a proc object. And whenever it is to be called, 'call' is used to execute that proc.

class Command
def initialize(input)
@local_proc = input
end

def return_proc
@local_proc
end
end

Now we have a class that stores a command. Now let us create a 'command'.

myProc = proc{ puts 8 }

Now we have a proc object that we want to use.

obj = Command.new(myProc)
obj.return_proc.call
8

Then we create an object storing myProc inside it. Then we use the object to return the proc and use 'call' on it to execute it. One could also create an array of commands by simply creating an array of Command objects and storing the proc in them. 

One important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The Strategy Pattern helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using Proc Objects. Below is an illustration of it:

class RoutePlanner
attr_accessor :strategy
def go(pointA, pointB)
strategy.call(*args)
end
def fastest … end
def shortest … end
end

Here, we have a class which helps us plan the route between two points A and B, depending upon whether we want the shortest path or the fastest path.

ctx = RoutePlanner.new
if on_foot
ctx.strategy = RoutePlanner.method(:shortest)
else
ctx.strategy = RoutePlanner.method(:fastest)
ctx.go(pointA, pointB)

Here, the path or strategy chosen is based on an if condition involving the value of the variable on_foot which is not known until runtime. Therefore, the algorithm that will be made use of to reach B starting from A, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==References==
http://designpatternsinruby.com/section01/article.html
http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-20T04:54:57Z

Vsuresw: /* Singleton Pattern */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - '''Christopher Alexander'''

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A Design Pattern is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in Object - Oriented Languages help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A Design Pattern describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Observer Design Pattern''''', which defines a one - to - many dependency among objects such that, the change in state of an object causes all its dependents to be notified and updated automatically.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the Singleton pattern. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class.

==Adapter Pattern==

An [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Design Pattern], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'.

==Observer Pattern==

The Observer Pattern, also known as the Dependents or Publish - Subscribe Pattern, defines a one-to-many dependency between objects such that the change in state of an object causes the dependent objects to be notified and updated automatically.

Partitioning of an application into a collection of co-operating classes, would require consistency to be maintained among these classes.

==Command Pattern==

At times, it is needed to pass around code that needs to be executed later. This is achieved by employing the Command Design Pattern which is used to factor out the action code of a class into its own object. It encapsulates a request as an object, allowing clients with different requests to be parameterized. The Command Pattern is implemented using Closures. A Command class holds an object, method along with the information needed to call a method at a later time. This information includes the method name with the values for the method parameters. The 'Call' method of Ruby brings the different parts together when needed.

This is illustrated using the following example:

One example is a check at a restaurant.
* The waiter/waitress takes an order from a customer and writes it on a check.
* The check is then queued for the cook, who prepares the food as requested by the customer.
* The check is later returned to the server, who uses it to bill the customer.

In this example, the check has nothing to do with the menu. In principle, the same checks could be used at any restaurant.

The command pattern is made up of a client, invoker and receiver. A client creates an object of the Command class and provides the information required to call the method at a later time. The invoker decides when the method should be called. The receiver is the class object which contains the code of the method. The usage of command objects makes it easier to construct components which need to execute methods at a later time without having knowledge about the method's owner or parameters.

This Pattern can be implemented using the Proc objects, which is a callable block of code that closes over the variables in scope when it was created. This gives us a concise implementation of Command Pattern.

Below is an illustration of the Command Design Pattern, using Proc Objects:

count = 0
commands = []
(1..10).each do |i|
commands << proc { count += i }
end
puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"

Another important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The Strategy Pattern helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using Proc Objects. Below is an illustration of it:

class RoutePlanner
attr_accessor :strategy
def go(pointA, pointB)
strategy.call(*args)
end
def fastest … end
def shortest … end
end

Here, we have a class which helps us plan the route between two points A and B, depending upon whether we want the shortest path or the fastest path.

ctx = RoutePlanner.new
if on_foot
ctx.strategy = RoutePlanner.method(:shortest)
else
ctx.strategy = RoutePlanner.method(:fastest)
ctx.go(pointA, pointB)

Here, the path or strategy chosen is based on an if condition involving the value of the variable on_foot which is not known until runtime. Therefore, the algorithm that will be made use of to reach B starting from A, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==References==
http://designpatternsinruby.com/section01/article.html
http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-20T04:50:42Z

Vsuresw: /* Adapter Pattern */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - '''Christopher Alexander'''

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A Design Pattern is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in Object - Oriented Languages help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A Design Pattern describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Observer Design Pattern''''', which defines a one - to - many dependency among objects such that, the change in state of an object causes all its dependents to be notified and updated automatically.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the Singleton pattern. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class.

==Adapter Pattern==

An [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Design Pattern], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:
 
In other words, when we want our new class to support a pre-existing feature, instead of modifying our new class, we can 'wrap' a similar feature in our new class to behave like the older class so that the pre-existing feature is supported.
 
Consider a software company located in United Kingdom. Lets assume they have these classes in their system.

class Bicycle
def rideBiCycle
puts 'Iam riding a bicycle'
end
end

The following class has a method which calls the method 'rideBiCycle' in the passed argument.

class Tester
def displayRide(object)
object.rideBiCycle
end
end

Now, If an American company buys this British company and tries to reuse the code. It has the following class already to its use.

class Bike
def rideBike
puts 'I am riding a bike'
end
end

But, the problem is that, Bike doesn't have the function 'rideBiCycle', so it cannot use the Tester class directly. If that tester class sits in a very important part of the code, there is a problem. Now the way out is to create a 'adapter' which assimilates a 'bike' object. This adapter is actually a 'Bike' which can mimic itself like a 'Bicycle' by supporting the method 'rideBiCycle'.
 
Now to understand it. We will create a bunch of instances.

cycle = Bicycle.new
cycle.rideBiCycle
Iam riding a bicycle

test = Tester.new
test.displayRide(cycle)

bike = Bike.new
bike.rideBike
I am riding a bike

So far, the respective objects are working well when used in isolation. But when we have to do this,

test.displayRide(bike)
NoMethodError: undefined method `rideBiCycle' for #<Bike:0x94b4494>

We encounter an error which is pretty obvious because rideBiCycle is not defined in Bike. Now let us define the adapter,

class BikeAdapter
def initialize(bike)
@bikeObject = bike
end
def rideBiCycle
@bikeObject.rideBike
end
end

Now we can try the failed method call like this,

adapter = BikeAdapter.new(bike)
test.displayRide(adapter)
Iam riding a bike

Voila! We have succesfully 'adapted' Bike class to behave like 'Bicycle'.

==Observer Pattern==

The Observer Pattern, also known as the Dependents or Publish - Subscribe Pattern, defines a one-to-many dependency between objects such that the change in state of an object causes the dependent objects to be notified and updated automatically.

Partitioning of an application into a collection of co-operating classes, would require consistency to be maintained among these classes.

==Command Pattern==

At times, it is needed to pass around code that needs to be executed later. This is achieved by employing the Command Design Pattern which is used to factor out the action code of a class into its own object. It encapsulates a request as an object, allowing clients with different requests to be parameterized. The Command Pattern is implemented using Closures. A Command class holds an object, method along with the information needed to call a method at a later time. This information includes the method name with the values for the method parameters. The 'Call' method of Ruby brings the different parts together when needed.

This is illustrated using the following example:

One example is a check at a restaurant.
* The waiter/waitress takes an order from a customer and writes it on a check.
* The check is then queued for the cook, who prepares the food as requested by the customer.
* The check is later returned to the server, who uses it to bill the customer.

In this example, the check has nothing to do with the menu. In principle, the same checks could be used at any restaurant.

The command pattern is made up of a client, invoker and receiver. A client creates an object of the Command class and provides the information required to call the method at a later time. The invoker decides when the method should be called. The receiver is the class object which contains the code of the method. The usage of command objects makes it easier to construct components which need to execute methods at a later time without having knowledge about the method's owner or parameters.

This Pattern can be implemented using the Proc objects, which is a callable block of code that closes over the variables in scope when it was created. This gives us a concise implementation of Command Pattern.

Below is an illustration of the Command Design Pattern, using Proc Objects:

count = 0
commands = []
(1..10).each do |i|
commands << proc { count += i }
end
puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"

Another important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The Strategy Pattern helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using Proc Objects. Below is an illustration of it:

class RoutePlanner
attr_accessor :strategy
def go(pointA, pointB)
strategy.call(*args)
end
def fastest … end
def shortest … end
end

Here, we have a class which helps us plan the route between two points A and B, depending upon whether we want the shortest path or the fastest path.

ctx = RoutePlanner.new
if on_foot
ctx.strategy = RoutePlanner.method(:shortest)
else
ctx.strategy = RoutePlanner.method(:fastest)
ctx.go(pointA, pointB)

Here, the path or strategy chosen is based on an if condition involving the value of the variable on_foot which is not known until runtime. Therefore, the algorithm that will be made use of to reach B starting from A, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==References==
http://designpatternsinruby.com/section01/article.html
http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-19T04:43:06Z

Vsuresw: /* Singleton Pattern */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - '''Christopher Alexander'''

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A Design Pattern is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in Object - Oriented Languages help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A Design Pattern describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Observer Design Pattern''''', which defines a one - to - many dependency among objects such that, the change in state of an object causes all its dependents to be notified and updated automatically.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the Singleton pattern. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class.

==Adapter Pattern==

An [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Design Pattern], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:

* “Wrapping” its own interface around the interface of a pre-existing class.
* Besides, it may also translate data formats from the caller to a form needed by the callee. Example: If the caller stores boolean value in terms of integers but the callee needs the values as 'true/false', the adapter pattern would extract the right value from the caller and pass it on to the callee. This ensures that the caller and callee can work together.

The purpose of an adapter is “to convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.”

Below is an illustration of the Adapter Pattern:

===Types of Adapter Patterns===

Based on the structure, there are two types of Adapter Patterns:

====Object Adapter Pattern====

The Adapter Pattern has an instance of the classit "wraps" and makes calls to this wrapped object alone.

====Class Adapter Pattern====

Polymorphic Interfaces are used by this type of pattern, where the interface that is expected and the interface that is available are both inherited or implemented. This is used in situations where the class providing the services you need does not provide the interface required.

==Observer Pattern==

The Observer Pattern, also known as the Dependents or Publish - Subscribe Pattern, defines a one-to-many dependency between objects such that the change in state of an object causes the dependent objects to be notified and updated automatically.

Partitioning of an application into a collection of co-operating classes, would require consistency to be maintained among these classes.

==Command Pattern==

At times, it is needed to pass around code that needs to be executed later. This is achieved by employing the Command Design Pattern which is used to factor out the action code of a class into its own object. It encapsulates a request as an object, allowing clients with different requests to be parameterized. The Command Pattern is implemented using Closures. A Command class holds an object, method along with the information needed to call a method at a later time. This information includes the method name with the values for the method parameters. The 'Call' method of Ruby brings the different parts together when needed.

This is illustrated using the following example:

One example is a check at a restaurant.
* The waiter/waitress takes an order from a customer and writes it on a check.
* The check is then queued for the cook, who prepares the food as requested by the customer.
* The check is later returned to the server, who uses it to bill the customer.

In this example, the check has nothing to do with the menu. In principle, the same checks could be used at any restaurant.

The command pattern is made up of a client, invoker and receiver. A client creates an object of the Command class and provides the information required to call the method at a later time. The invoker decides when the method should be called. The receiver is the class object which contains the code of the method. The usage of command objects makes it easier to construct components which need to execute methods at a later time without having knowledge about the method's owner or parameters.

This Pattern can be implemented using the Proc objects, which is a callable block of code that closes over the variables in scope when it was created. This gives us a concise implementation of Command Pattern.

Below is an illustration of the Command Design Pattern, using Proc Objects:

count = 0
commands = []
(1..10).each do |i|
commands << proc { count += i }
end
puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"

Another important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The Strategy Pattern helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using Proc Objects. Below is an illustration of it:

class RoutePlanner
attr_accessor :strategy
def go(pointA, pointB)
strategy.call(*args)
end
def fastest … end
def shortest … end
end

Here, we have a class which helps us plan the route between two points A and B, depending upon whether we want the shortest path or the fastest path.

ctx = RoutePlanner.new
if on_foot
ctx.strategy = RoutePlanner.method(:shortest)
else
ctx.strategy = RoutePlanner.method(:fastest)
ctx.go(pointA, pointB)

Here, the path or strategy chosen is based on an if condition involving the value of the variable on_foot which is not known until runtime. Therefore, the algorithm that will be made use of to reach B starting from A, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==References==
http://designpatternsinruby.com/section01/article.html
http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-19T04:41:40Z

Vsuresw: /* Singleton Pattern */

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - '''Christopher Alexander'''

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A Design Pattern is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in Object - Oriented Languages help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A Design Pattern describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Observer Design Pattern''''', which defines a one - to - many dependency among objects such that, the change in state of an object causes all its dependents to be notified and updated automatically.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the Singleton pattern. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end
>Initialised
 

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.
 
Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class.

==Adapter Pattern==

An [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Design Pattern], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:

* “Wrapping” its own interface around the interface of a pre-existing class.
* Besides, it may also translate data formats from the caller to a form needed by the callee. Example: If the caller stores boolean value in terms of integers but the callee needs the values as 'true/false', the adapter pattern would extract the right value from the caller and pass it on to the callee. This ensures that the caller and callee can work together.

The purpose of an adapter is “to convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.”

Below is an illustration of the Adapter Pattern:

===Types of Adapter Patterns===

Based on the structure, there are two types of Adapter Patterns:

====Object Adapter Pattern====

The Adapter Pattern has an instance of the classit "wraps" and makes calls to this wrapped object alone.

====Class Adapter Pattern====

Polymorphic Interfaces are used by this type of pattern, where the interface that is expected and the interface that is available are both inherited or implemented. This is used in situations where the class providing the services you need does not provide the interface required.

==Observer Pattern==

The Observer Pattern, also known as the Dependents or Publish - Subscribe Pattern, defines a one-to-many dependency between objects such that the change in state of an object causes the dependent objects to be notified and updated automatically.

Partitioning of an application into a collection of co-operating classes, would require consistency to be maintained among these classes.

==Command Pattern==

At times, it is needed to pass around code that needs to be executed later. This is achieved by employing the Command Design Pattern which is used to factor out the action code of a class into its own object. It encapsulates a request as an object, allowing clients with different requests to be parameterized. The Command Pattern is implemented using Closures. A Command class holds an object, method along with the information needed to call a method at a later time. This information includes the method name with the values for the method parameters. The 'Call' method of Ruby brings the different parts together when needed.

This is illustrated using the following example:

One example is a check at a restaurant.
* The waiter/waitress takes an order from a customer and writes it on a check.
* The check is then queued for the cook, who prepares the food as requested by the customer.
* The check is later returned to the server, who uses it to bill the customer.

In this example, the check has nothing to do with the menu. In principle, the same checks could be used at any restaurant.

The command pattern is made up of a client, invoker and receiver. A client creates an object of the Command class and provides the information required to call the method at a later time. The invoker decides when the method should be called. The receiver is the class object which contains the code of the method. The usage of command objects makes it easier to construct components which need to execute methods at a later time without having knowledge about the method's owner or parameters.

This Pattern can be implemented using the Proc objects, which is a callable block of code that closes over the variables in scope when it was created. This gives us a concise implementation of Command Pattern.

Below is an illustration of the Command Design Pattern, using Proc Objects:

count = 0
commands = []
(1..10).each do |i|
commands << proc { count += i }
end
puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"

Another important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The Strategy Pattern helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using Proc Objects. Below is an illustration of it:

class RoutePlanner
attr_accessor :strategy
def go(pointA, pointB)
strategy.call(*args)
end
def fastest … end
def shortest … end
end

Here, we have a class which helps us plan the route between two points A and B, depending upon whether we want the shortest path or the fastest path.

ctx = RoutePlanner.new
if on_foot
ctx.strategy = RoutePlanner.method(:shortest)
else
ctx.strategy = RoutePlanner.method(:fastest)
ctx.go(pointA, pointB)

Here, the path or strategy chosen is based on an if condition involving the value of the variable on_foot which is not known until runtime. Therefore, the algorithm that will be made use of to reach B starting from A, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==References==
http://designpatternsinruby.com/section01/article.html
http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf

CSC/ECE 517 Fall 2011/ch4 4h sv

2011-10-19T04:40:46Z

Vsuresw:

=Design Patterns in Ruby=

''"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice"'' - '''Christopher Alexander'''

''"In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design".''

A Design Pattern is a template to solve a problem which can be used in many different situations. It names, abstracts and identifies the key aspects of a common design structure that makes it useful for creating a reusable object - oriented design. Design Patterns in Object - Oriented Languages help show the relationship between the different classes and objects in the program. Design Patterns are tools for building software.

__TOC__

==Overview==

A Design Pattern describes a problem which repeatedly occurs in our environment and also the core of the solution to that problem, in a way that this solution can be re-used many times, without ever doing it the same way twice.

The description of a pattern consists of:
* '''''The Pattern name''''', describes the design pattern, its solutions and consequences.
* '''''The problem the pattern solves''''', describes when to apply the pattern.
* '''''The solution''''', describes the elements that make up the design, their relationships, responsibilities, and collaborations.
* '''''The consequences''''', describes the results of applying the pattern to the problem.

The different types of design patterns are listed below:

* '''''Singleton Design Pattern''''', which is used to have only one instance of a class.
* '''''Adapter Design Pattern''''', which enables classes with incompatible interfaces to work together.
* '''''Observer Design Pattern''''', which defines a one - to - many dependency among objects such that, the change in state of an object causes all its dependents to be notified and updated automatically.
* '''''Command Design Pattern''''', which enables to pass around the code that needs to be executed later.
* '''''Algorithm Strategy Pattern''''', which helps choose an algorithm to fulfill a task based on some "parameter" of the situation.

==Singleton Pattern==
The first design pattern one should know about is the Singleton pattern. It is basically the case, where the Class can instantiate only one object.

Below is an illustration of the general Syntax of Singleton Design Pattern in Ruby:

require 'singleton'
class Example
include Singleton
...
end

It could be noticed that one must 'require' a module called 'singleton' and include the module within the class.
This adds the singleton flavour to your class. Now to test if it can create multiple instances, we can inquisitively try this,

raisesError = Example.new
ruby-1.9.2-p290 :026 > raisesError = Example.new
NoMethodError: private method `new' called for Example:Class

We will soon find out we are greeted with the NoMethodError( Some kind of an error is expected ). So how do we use a singleton pattern? We create an instance of it using the keyword 'instance'

a = Example.instance
=> #<Example:0x9361cb8>
b = Example.instance
=> #<Example:0x9361cb8>

The above illustrates how to create the instance of the Singleton class. It also illustrates another point. Even though two 'instances' have supposedly been created, both of them happen to contain reference to the same object.
This further proves that only one object can be created for a Singleton. 
That was the Ruby's default way to create singletons. Singletons can be created manually without using the 'singleton' module.

class Single_ton
def initialize
puts "Initialised"
end

@@instance = Single_ton.new

def self.instance
return @@instance
end

def print_something
puts "This prints something"
end

private_class_method :new
end
>Initialised

The above snippet is actually a singleton class. A cursory reading shall read the logic behind singleton-ing the class. An object to the same class has been created as a class variable. a ".instance" method is defined. One more thing to notice is that, "new" method is made 'private'. This makes sure that one cannot create anymore objects of the singleton.

Single_ton.instance
=> #<Single_ton:0x94483d4>
Single_ton.instance.print_something
This prints something

The above just shows that our class 'behaves' like a singleton. we have a '.instance' method defind and it works.
The method could be accessed by accessing the lone object inside the class.

The Singleton Pattern is useful in situations where serialization is desirable, example logging, communication and database access etc. In these cases, only a single instance of the class is created which accesses and modifies the methods of the class. This ensures safety and also make the single instance responsible for the class.

==Adapter Pattern==

An [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Design Pattern], also known as the Wrapper Pattern enables classes with incompatible interfaces to work together, by providing the users with its interface. This is achieved by:

* “Wrapping” its own interface around the interface of a pre-existing class.
* Besides, it may also translate data formats from the caller to a form needed by the callee. Example: If the caller stores boolean value in terms of integers but the callee needs the values as 'true/false', the adapter pattern would extract the right value from the caller and pass it on to the callee. This ensures that the caller and callee can work together.

The purpose of an adapter is “to convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.”

Below is an illustration of the Adapter Pattern:

===Types of Adapter Patterns===

Based on the structure, there are two types of Adapter Patterns:

====Object Adapter Pattern====

The Adapter Pattern has an instance of the classit "wraps" and makes calls to this wrapped object alone.

====Class Adapter Pattern====

Polymorphic Interfaces are used by this type of pattern, where the interface that is expected and the interface that is available are both inherited or implemented. This is used in situations where the class providing the services you need does not provide the interface required.

==Observer Pattern==

The Observer Pattern, also known as the Dependents or Publish - Subscribe Pattern, defines a one-to-many dependency between objects such that the change in state of an object causes the dependent objects to be notified and updated automatically.

Partitioning of an application into a collection of co-operating classes, would require consistency to be maintained among these classes.

==Command Pattern==

At times, it is needed to pass around code that needs to be executed later. This is achieved by employing the Command Design Pattern which is used to factor out the action code of a class into its own object. It encapsulates a request as an object, allowing clients with different requests to be parameterized. The Command Pattern is implemented using Closures. A Command class holds an object, method along with the information needed to call a method at a later time. This information includes the method name with the values for the method parameters. The 'Call' method of Ruby brings the different parts together when needed.

This is illustrated using the following example:

One example is a check at a restaurant.
* The waiter/waitress takes an order from a customer and writes it on a check.
* The check is then queued for the cook, who prepares the food as requested by the customer.
* The check is later returned to the server, who uses it to bill the customer.

In this example, the check has nothing to do with the menu. In principle, the same checks could be used at any restaurant.

The command pattern is made up of a client, invoker and receiver. A client creates an object of the Command class and provides the information required to call the method at a later time. The invoker decides when the method should be called. The receiver is the class object which contains the code of the method. The usage of command objects makes it easier to construct components which need to execute methods at a later time without having knowledge about the method's owner or parameters.

This Pattern can be implemented using the Proc objects, which is a callable block of code that closes over the variables in scope when it was created. This gives us a concise implementation of Command Pattern.

Below is an illustration of the Command Design Pattern, using Proc Objects:

count = 0
commands = []
(1..10).each do |i|
commands << proc { count += i }
end
puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"

Another important use of the Command Pattern is to enable the client undo what he has already done, or redo what has been undone by the user. This is done by maintaining a history of the commands executed. As and when the user makes changes, the system creates command after command, executing each command immediately to effect the change. Every undo - able command holds two methods - the execute and the unexecute method.
The commands are stored in a list and when the user decides to undo a change, the last command on the list is executed to undo the change. The changes can be undone, by going back the history of commands. The redo is done in the similar way where the the commands are re-executed beginning from the last change that what undone to reapply the changes undone. A simple example of the undo - redo use of a Command Pattern is a Calculator with many undo - redo options.

==Algorithm Strategy Pattern==

The Strategy Pattern helps choose an algorithm to accomplish a task based on some "parameters" of the situation. Also known as the Policy Pattern, it enables selection of algorithms at runtime. This pattern allows the algorithm to vary irresepctive of the user that uses it.

The strategy pattern ''"defines a family of algorithms, encapsulates each one, and makes them interchangeable"''.

Consider as an example, a class that that converts among different types of file formats like jpeg, jif, png etc. We can write a case statement to choose what algorithm has to be employed for each type of format. Another example could be performing validation on incoming data. Here we can select a validation algorithm based on the type and source of data.

A Strategy Pattern is best implemented using Proc Objects. Below is an illustration of it:

class RoutePlanner
attr_accessor :strategy
def go(pointA, pointB)
strategy.call(*args)
end
def fastest … end
def shortest … end
end

Here, we have a class which helps us plan the route between two points A and B, depending upon whether we want the shortest path or the fastest path.

ctx = RoutePlanner.new
if on_foot
ctx.strategy = RoutePlanner.method(:shortest)
else
ctx.strategy = RoutePlanner.method(:fastest)
ctx.go(pointA, pointB)

Here, the path or strategy chosen is based on an if condition involving the value of the variable on_foot which is not known until runtime. Therefore, the algorithm that will be made use of to reach B starting from A, is decided at run time. The strategy that will be chosen depends on many factors which change dynamically.

==Differences between Command and Strategy Pattern==

* A Command Pattern encapsulates a single action. A command object has a single method with a generic signature associated with it.
* A Strategy Pattern, enables us to customize an algorithm, deciding which algorithm has to be made use of depending on a number of dynamically changing factors. A given strategy has many methods associated with it.

==References==
http://designpatternsinruby.com/section01/article.html
http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-15T00:42:24Z

Vsuresw: /* Currying */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 reflective], [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented], [http://en.wikipedia.org/wiki/Interpreted_language single-pass interpreted] programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports [http://en.wikipedia.org/wiki/Functional_programming functional], [http://en.wikipedia.org/wiki/Imperative_programming imperative], reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like Java and C++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than [http://www.perl.org/ Perl] and more Object Oriented than [http://www.python.org/ Python].
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller MVC] based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. [http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Purely object oriented]'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. [http://c2.com/cgi/wiki?DynamicTyping Dynamically typed]'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Blocks and Closures]'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. [http://www.rubyist.net/~slagell/ruby/iterators.html Built in Iterators]'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. [http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Multiple Inheritance through Mixins]'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. [http://en.wikipedia.org/wiki/Duck_typing Unbounded Polymorphism - "Duck Typing"]'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection]'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. [http://www.regular-expressions.info/ruby.html Syntax level Perl compatible for regular expressions]'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. [http://designpatternsinruby.com/ Built-in support for certain Design Patterns]'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. [http://corelib.rubyonrails.org/classes/GC.html Mark-and-Sweep garbage collection]'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. [http://www.ruby-doc.org/core-1.9.2/Thread.html OS independent threading]'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. [http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Easy interface to C modules]'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. [http://www.ruby-lang.org/en/about/ Portable easily]'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the [http://en.wikipedia.org/wiki/Interactive_Ruby_Shell IRB]. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by [http://www.eclipse.org/ Eclipse]. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

[http://www.jetbrains.com/ruby/ RubyMine] is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object. [http://rubylearning.com/satishtalim/writing_own_ruby_methods.html This] is really helpful to learn more about methods in Ruby.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called [http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing].

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array
 
[http://www.sitepoint.com/typing-versus-dynamic-typing/ Here] is something we got off the internet which explains Dynamic typing well although its not particular to Ruby.

==Arrays==

An [http://www.ruby-doc.org/core-1.9.2/Array.html array] in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Strings==

A [http://www.rubyist.net/~slagell/ruby/strings.html String] in Ruby may be double-quoted ("...") or single-quoted ('...').

However, double-quoting and single-quoting have different effects in some cases. A double-quoted string allows character escapes by a leading backslash, and the evaluation of embedded expressions using #{}. A single-quoted string does not interpret this. This is shown in the example below:

string1 = "abc"
>> "abc"

string2 = 'efg'
>> "efg"

puts "a\nb\nc"
>>a
>>b
>>c
>>nil

puts 'a\nb\n'
>>a\nb\nc
>>nil

puts "abcd #{5*3} efg"
>>"abcd 15 efg"

puts var = " abc "
>>" abc "
puts "1234#{var}5678"
>>"1234 abc 5678"

Ruby strings can be concatenated using + operator. A string can be repeated multiple times using * operator. The example below shows the use of + and * operators. Ruby string handling is more powerful than C. Since Ruby, provides support for regular expressions, string handling and pattern matching can be made very efficiently and easily.

puts "foo" + "bar"
>>"foobar"

puts "foo" * 2
>>"foofoo"

===Symbols===

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] in Ruby are Strings, just with an important difference, Symbols are immutable while Strings are not. Mutable objects can be changed after assignment while immutable objects can only be overwritten. Ruby is quite unique in offering mutable Strings, which adds greatly to its expressiveness. However mutable Strings can have their share of issues in terms of creating unexpected results and reduced performance. It is for this reason Ruby also offers programmers the choice of Symbols.

Symbols need not contain only alphanumeric characters, by using quotes you can not only use the same characters as you would in a String, but also interpolate Symbols as well. Syntactically, a Symbol needs a colon : prepended. Symbols are actually so similar to Strings that converting between the two is very simple and consistent.

"hello"
:hello

"hello world"
:"hello world"

bang = "!"

"hello world#{bang}" # => "hello world!"
:"hello world#{bang}" # => :"hello world!"

 

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ This] and [http://www.troubleshooters.com/codecorn/ruby/symbols.htm This] delve deeply into the difference between string and symbol. Well they are interesting worth reading atleast once.

==Hashes==

[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash] is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Block] is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
This example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you don't have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambdas in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

[http://www.rubyist.net/~slagell/ruby/iterators.html Iterator] is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closure] in Ruby is a block that closes over. Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

[http://en.wikipedia.org/wiki/Currying Currying] is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.
 [http://asemanfar.com/Currying-in-Ruby Here] is a set of nice programming examples in Ruby to explain/implement currying.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
[http://en.wikipedia.org/wiki/Interpreted_language Interpreted language] 
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection] 
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic language] 
[http://www.python.org/ Python] 
[http://www.perl.org/ Perl] 
[http://rubyonrails.org/ Ruby on Rails] 
[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model View Controller - MVC] 
[http://pragprog.com/book/ppmetr/metaprogramming-ruby Metaprogramming Ruby: Program Like the Ruby Pros] 
[http://designpatternsinruby.com/ Design Patterns in Ruby] 
[http://corelib.rubyonrails.org/classes/GC.html Garbage Collection in Ruby] 
[http://www.ruby-doc.org/core-1.9.2/Thread.html Threads in Ruby] 
[http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Ruby interface to C modules] 
[http://en.wikipedia.org/wiki/Currying Currying]

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
[http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Object Oriented Ruby] 
[http://www.skorks.com/ www.skorks.com] 
[http://www.ruby-lang.org/en/about/ Features of Ruby] 
[http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing] 
[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closures] 
[http://www.rubyist.net/~slagell/ruby/iterators.html Iterators in Ruby] 
[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] 
[http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Modules and Mixins] 
[http://en.wikipedia.org/wiki/Duck_typing Duck Typing - Unbounded Polymorphism] 
[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] 
[http://www.regular-expressions.info/ruby.html Regular expressions] 
[http://en.wikipedia.org/wiki/Interactive_Ruby_Shell Interactive Ruby Browser] 
[http://www.ruby-doc.org/core-1.9.2/Array.html Array class in Ruby] 
[http://www.rubyist.net/~slagell/ruby/strings.html String] 
[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] 
[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash class in Ruby] 
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Blocks, Procs and Lambdas] 

[http://www.csc.ncsu.edu/faculty/efg/517/f11/schedule CSC517 Class notes]

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-15T00:37:58Z

Vsuresw: /* Symbols */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 reflective], [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented], [http://en.wikipedia.org/wiki/Interpreted_language single-pass interpreted] programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports [http://en.wikipedia.org/wiki/Functional_programming functional], [http://en.wikipedia.org/wiki/Imperative_programming imperative], reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like Java and C++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than [http://www.perl.org/ Perl] and more Object Oriented than [http://www.python.org/ Python].
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller MVC] based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. [http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Purely object oriented]'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. [http://c2.com/cgi/wiki?DynamicTyping Dynamically typed]'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Blocks and Closures]'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. [http://www.rubyist.net/~slagell/ruby/iterators.html Built in Iterators]'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. [http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Multiple Inheritance through Mixins]'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. [http://en.wikipedia.org/wiki/Duck_typing Unbounded Polymorphism - "Duck Typing"]'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection]'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. [http://www.regular-expressions.info/ruby.html Syntax level Perl compatible for regular expressions]'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. [http://designpatternsinruby.com/ Built-in support for certain Design Patterns]'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. [http://corelib.rubyonrails.org/classes/GC.html Mark-and-Sweep garbage collection]'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. [http://www.ruby-doc.org/core-1.9.2/Thread.html OS independent threading]'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. [http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Easy interface to C modules]'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. [http://www.ruby-lang.org/en/about/ Portable easily]'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the [http://en.wikipedia.org/wiki/Interactive_Ruby_Shell IRB]. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by [http://www.eclipse.org/ Eclipse]. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

[http://www.jetbrains.com/ruby/ RubyMine] is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object. [http://rubylearning.com/satishtalim/writing_own_ruby_methods.html This] is really helpful to learn more about methods in Ruby.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called [http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing].

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array
 
[http://www.sitepoint.com/typing-versus-dynamic-typing/ Here] is something we got off the internet which explains Dynamic typing well although its not particular to Ruby.

==Arrays==

An [http://www.ruby-doc.org/core-1.9.2/Array.html array] in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Strings==

A [http://www.rubyist.net/~slagell/ruby/strings.html String] in Ruby may be double-quoted ("...") or single-quoted ('...').

However, double-quoting and single-quoting have different effects in some cases. A double-quoted string allows character escapes by a leading backslash, and the evaluation of embedded expressions using #{}. A single-quoted string does not interpret this. This is shown in the example below:

string1 = "abc"
>> "abc"

string2 = 'efg'
>> "efg"

puts "a\nb\nc"
>>a
>>b
>>c
>>nil

puts 'a\nb\n'
>>a\nb\nc
>>nil

puts "abcd #{5*3} efg"
>>"abcd 15 efg"

puts var = " abc "
>>" abc "
puts "1234#{var}5678"
>>"1234 abc 5678"

Ruby strings can be concatenated using + operator. A string can be repeated multiple times using * operator. The example below shows the use of + and * operators. Ruby string handling is more powerful than C. Since Ruby, provides support for regular expressions, string handling and pattern matching can be made very efficiently and easily.

puts "foo" + "bar"
>>"foobar"

puts "foo" * 2
>>"foofoo"

===Symbols===

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] in Ruby are Strings, just with an important difference, Symbols are immutable while Strings are not. Mutable objects can be changed after assignment while immutable objects can only be overwritten. Ruby is quite unique in offering mutable Strings, which adds greatly to its expressiveness. However mutable Strings can have their share of issues in terms of creating unexpected results and reduced performance. It is for this reason Ruby also offers programmers the choice of Symbols.

Symbols need not contain only alphanumeric characters, by using quotes you can not only use the same characters as you would in a String, but also interpolate Symbols as well. Syntactically, a Symbol needs a colon : prepended. Symbols are actually so similar to Strings that converting between the two is very simple and consistent.

"hello"
:hello

"hello world"
:"hello world"

bang = "!"

"hello world#{bang}" # => "hello world!"
:"hello world#{bang}" # => :"hello world!"

 

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ This] and [http://www.troubleshooters.com/codecorn/ruby/symbols.htm This] delve deeply into the difference between string and symbol. Well they are interesting worth reading atleast once.

==Hashes==

[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash] is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Block] is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
This example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you don't have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambdas in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

[http://www.rubyist.net/~slagell/ruby/iterators.html Iterator] is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closure] in Ruby is a block that closes over. Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

[http://en.wikipedia.org/wiki/Currying Currying] is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
[http://en.wikipedia.org/wiki/Interpreted_language Interpreted language] 
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection] 
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic language] 
[http://www.python.org/ Python] 
[http://www.perl.org/ Perl] 
[http://rubyonrails.org/ Ruby on Rails] 
[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model View Controller - MVC] 
[http://pragprog.com/book/ppmetr/metaprogramming-ruby Metaprogramming Ruby: Program Like the Ruby Pros] 
[http://designpatternsinruby.com/ Design Patterns in Ruby] 
[http://corelib.rubyonrails.org/classes/GC.html Garbage Collection in Ruby] 
[http://www.ruby-doc.org/core-1.9.2/Thread.html Threads in Ruby] 
[http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Ruby interface to C modules] 
[http://en.wikipedia.org/wiki/Currying Currying]

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
[http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Object Oriented Ruby] 
[http://www.skorks.com/ www.skorks.com] 
[http://www.ruby-lang.org/en/about/ Features of Ruby] 
[http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing] 
[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closures] 
[http://www.rubyist.net/~slagell/ruby/iterators.html Iterators in Ruby] 
[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] 
[http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Modules and Mixins] 
[http://en.wikipedia.org/wiki/Duck_typing Duck Typing - Unbounded Polymorphism] 
[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] 
[http://www.regular-expressions.info/ruby.html Regular expressions] 
[http://en.wikipedia.org/wiki/Interactive_Ruby_Shell Interactive Ruby Browser] 
[http://www.ruby-doc.org/core-1.9.2/Array.html Array class in Ruby] 
[http://www.rubyist.net/~slagell/ruby/strings.html String] 
[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] 
[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash class in Ruby] 
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Blocks, Procs and Lambdas] 

[http://www.csc.ncsu.edu/faculty/efg/517/f11/schedule CSC517 Class notes]

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-15T00:37:25Z

Vsuresw: /* Symbols */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 reflective], [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented], [http://en.wikipedia.org/wiki/Interpreted_language single-pass interpreted] programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports [http://en.wikipedia.org/wiki/Functional_programming functional], [http://en.wikipedia.org/wiki/Imperative_programming imperative], reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like Java and C++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than [http://www.perl.org/ Perl] and more Object Oriented than [http://www.python.org/ Python].
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller MVC] based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. [http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Purely object oriented]'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. [http://c2.com/cgi/wiki?DynamicTyping Dynamically typed]'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Blocks and Closures]'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. [http://www.rubyist.net/~slagell/ruby/iterators.html Built in Iterators]'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. [http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Multiple Inheritance through Mixins]'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. [http://en.wikipedia.org/wiki/Duck_typing Unbounded Polymorphism - "Duck Typing"]'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection]'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. [http://www.regular-expressions.info/ruby.html Syntax level Perl compatible for regular expressions]'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. [http://designpatternsinruby.com/ Built-in support for certain Design Patterns]'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. [http://corelib.rubyonrails.org/classes/GC.html Mark-and-Sweep garbage collection]'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. [http://www.ruby-doc.org/core-1.9.2/Thread.html OS independent threading]'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. [http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Easy interface to C modules]'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. [http://www.ruby-lang.org/en/about/ Portable easily]'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the [http://en.wikipedia.org/wiki/Interactive_Ruby_Shell IRB]. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by [http://www.eclipse.org/ Eclipse]. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

[http://www.jetbrains.com/ruby/ RubyMine] is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object. [http://rubylearning.com/satishtalim/writing_own_ruby_methods.html This] is really helpful to learn more about methods in Ruby.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called [http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing].

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array
 
[http://www.sitepoint.com/typing-versus-dynamic-typing/ Here] is something we got off the internet which explains Dynamic typing well although its not particular to Ruby.

==Arrays==

An [http://www.ruby-doc.org/core-1.9.2/Array.html array] in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Strings==

A [http://www.rubyist.net/~slagell/ruby/strings.html String] in Ruby may be double-quoted ("...") or single-quoted ('...').

However, double-quoting and single-quoting have different effects in some cases. A double-quoted string allows character escapes by a leading backslash, and the evaluation of embedded expressions using #{}. A single-quoted string does not interpret this. This is shown in the example below:

string1 = "abc"
>> "abc"

string2 = 'efg'
>> "efg"

puts "a\nb\nc"
>>a
>>b
>>c
>>nil

puts 'a\nb\n'
>>a\nb\nc
>>nil

puts "abcd #{5*3} efg"
>>"abcd 15 efg"

puts var = " abc "
>>" abc "
puts "1234#{var}5678"
>>"1234 abc 5678"

Ruby strings can be concatenated using + operator. A string can be repeated multiple times using * operator. The example below shows the use of + and * operators. Ruby string handling is more powerful than C. Since Ruby, provides support for regular expressions, string handling and pattern matching can be made very efficiently and easily.

puts "foo" + "bar"
>>"foobar"

puts "foo" * 2
>>"foofoo"

===Symbols===

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] in Ruby are Strings, just with an important difference, Symbols are immutable while Strings are not. Mutable objects can be changed after assignment while immutable objects can only be overwritten. Ruby is quite unique in offering mutable Strings, which adds greatly to its expressiveness. However mutable Strings can have their share of issues in terms of creating unexpected results and reduced performance. It is for this reason Ruby also offers programmers the choice of Symbols.

Symbols need not contain only alphanumeric characters, by using quotes you can not only use the same characters as you would in a String, but also interpolate Symbols as well. Syntactically, a Symbol needs a colon : prepended. Symbols are actually so similar to Strings that converting between the two is very simple and consistent.

"hello"
:hello

"hello world"
:"hello world"

bang = "!"

"hello world#{bang}" # => "hello world!"
:"hello world#{bang}" # => :"hello world!"

 

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ This] and [http://www.troubleshooters.com/codecorn/ruby/symbols.htm This] delve deeply into the difference between string and symbol. Well they are worth a read.

==Hashes==

[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash] is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Block] is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
This example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you don't have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambdas in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

[http://www.rubyist.net/~slagell/ruby/iterators.html Iterator] is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closure] in Ruby is a block that closes over. Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

[http://en.wikipedia.org/wiki/Currying Currying] is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
[http://en.wikipedia.org/wiki/Interpreted_language Interpreted language] 
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection] 
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic language] 
[http://www.python.org/ Python] 
[http://www.perl.org/ Perl] 
[http://rubyonrails.org/ Ruby on Rails] 
[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model View Controller - MVC] 
[http://pragprog.com/book/ppmetr/metaprogramming-ruby Metaprogramming Ruby: Program Like the Ruby Pros] 
[http://designpatternsinruby.com/ Design Patterns in Ruby] 
[http://corelib.rubyonrails.org/classes/GC.html Garbage Collection in Ruby] 
[http://www.ruby-doc.org/core-1.9.2/Thread.html Threads in Ruby] 
[http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Ruby interface to C modules] 
[http://en.wikipedia.org/wiki/Currying Currying]

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
[http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Object Oriented Ruby] 
[http://www.skorks.com/ www.skorks.com] 
[http://www.ruby-lang.org/en/about/ Features of Ruby] 
[http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing] 
[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closures] 
[http://www.rubyist.net/~slagell/ruby/iterators.html Iterators in Ruby] 
[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] 
[http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Modules and Mixins] 
[http://en.wikipedia.org/wiki/Duck_typing Duck Typing - Unbounded Polymorphism] 
[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] 
[http://www.regular-expressions.info/ruby.html Regular expressions] 
[http://en.wikipedia.org/wiki/Interactive_Ruby_Shell Interactive Ruby Browser] 
[http://www.ruby-doc.org/core-1.9.2/Array.html Array class in Ruby] 
[http://www.rubyist.net/~slagell/ruby/strings.html String] 
[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] 
[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash class in Ruby] 
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Blocks, Procs and Lambdas] 

[http://www.csc.ncsu.edu/faculty/efg/517/f11/schedule CSC517 Class notes]

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-15T00:34:04Z

Vsuresw: /* Dynamic Typing */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 reflective], [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented], [http://en.wikipedia.org/wiki/Interpreted_language single-pass interpreted] programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports [http://en.wikipedia.org/wiki/Functional_programming functional], [http://en.wikipedia.org/wiki/Imperative_programming imperative], reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like Java and C++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than [http://www.perl.org/ Perl] and more Object Oriented than [http://www.python.org/ Python].
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller MVC] based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. [http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Purely object oriented]'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. [http://c2.com/cgi/wiki?DynamicTyping Dynamically typed]'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Blocks and Closures]'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. [http://www.rubyist.net/~slagell/ruby/iterators.html Built in Iterators]'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. [http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Multiple Inheritance through Mixins]'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. [http://en.wikipedia.org/wiki/Duck_typing Unbounded Polymorphism - "Duck Typing"]'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection]'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. [http://www.regular-expressions.info/ruby.html Syntax level Perl compatible for regular expressions]'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. [http://designpatternsinruby.com/ Built-in support for certain Design Patterns]'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. [http://corelib.rubyonrails.org/classes/GC.html Mark-and-Sweep garbage collection]'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. [http://www.ruby-doc.org/core-1.9.2/Thread.html OS independent threading]'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. [http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Easy interface to C modules]'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. [http://www.ruby-lang.org/en/about/ Portable easily]'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the [http://en.wikipedia.org/wiki/Interactive_Ruby_Shell IRB]. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by [http://www.eclipse.org/ Eclipse]. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

[http://www.jetbrains.com/ruby/ RubyMine] is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object. [http://rubylearning.com/satishtalim/writing_own_ruby_methods.html This] is really helpful to learn more about methods in Ruby.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called [http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing].

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array
 
[http://www.sitepoint.com/typing-versus-dynamic-typing/ Here] is something we got off the internet which explains Dynamic typing well although its not particular to Ruby.

==Arrays==

An [http://www.ruby-doc.org/core-1.9.2/Array.html array] in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Strings==

A [http://www.rubyist.net/~slagell/ruby/strings.html String] in Ruby may be double-quoted ("...") or single-quoted ('...').

However, double-quoting and single-quoting have different effects in some cases. A double-quoted string allows character escapes by a leading backslash, and the evaluation of embedded expressions using #{}. A single-quoted string does not interpret this. This is shown in the example below:

string1 = "abc"
>> "abc"

string2 = 'efg'
>> "efg"

puts "a\nb\nc"
>>a
>>b
>>c
>>nil

puts 'a\nb\n'
>>a\nb\nc
>>nil

puts "abcd #{5*3} efg"
>>"abcd 15 efg"

puts var = " abc "
>>" abc "
puts "1234#{var}5678"
>>"1234 abc 5678"

Ruby strings can be concatenated using + operator. A string can be repeated multiple times using * operator. The example below shows the use of + and * operators. Ruby string handling is more powerful than C. Since Ruby, provides support for regular expressions, string handling and pattern matching can be made very efficiently and easily.

puts "foo" + "bar"
>>"foobar"

puts "foo" * 2
>>"foofoo"

===Symbols===

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] in Ruby are Strings, just with an important difference, Symbols are immutable while Strings are not. Mutable objects can be changed after assignment while immutable objects can only be overwritten. Ruby is quite unique in offering mutable Strings, which adds greatly to its expressiveness. However mutable Strings can have their share of issues in terms of creating unexpected results and reduced performance. It is for this reason Ruby also offers programmers the choice of Symbols.

Symbols need not contain only alphanumeric characters, by using quotes you can not only use the same characters as you would in a String, but also interpolate Symbols as well. Syntactically, a Symbol needs a colon : prepended. Symbols are actually so similar to Strings that converting between the two is very simple and consistent.

"hello"
:hello

"hello world"
:"hello world"

bang = "!"

"hello world#{bang}" # => "hello world!"
:"hello world#{bang}" # => :"hello world!"

==Hashes==

[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash] is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Block] is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
This example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you don't have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambdas in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

[http://www.rubyist.net/~slagell/ruby/iterators.html Iterator] is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closure] in Ruby is a block that closes over. Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

[http://en.wikipedia.org/wiki/Currying Currying] is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
[http://en.wikipedia.org/wiki/Interpreted_language Interpreted language] 
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection] 
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic language] 
[http://www.python.org/ Python] 
[http://www.perl.org/ Perl] 
[http://rubyonrails.org/ Ruby on Rails] 
[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model View Controller - MVC] 
[http://pragprog.com/book/ppmetr/metaprogramming-ruby Metaprogramming Ruby: Program Like the Ruby Pros] 
[http://designpatternsinruby.com/ Design Patterns in Ruby] 
[http://corelib.rubyonrails.org/classes/GC.html Garbage Collection in Ruby] 
[http://www.ruby-doc.org/core-1.9.2/Thread.html Threads in Ruby] 
[http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Ruby interface to C modules] 
[http://en.wikipedia.org/wiki/Currying Currying]

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
[http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Object Oriented Ruby] 
[http://www.skorks.com/ www.skorks.com] 
[http://www.ruby-lang.org/en/about/ Features of Ruby] 
[http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing] 
[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closures] 
[http://www.rubyist.net/~slagell/ruby/iterators.html Iterators in Ruby] 
[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] 
[http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Modules and Mixins] 
[http://en.wikipedia.org/wiki/Duck_typing Duck Typing - Unbounded Polymorphism] 
[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] 
[http://www.regular-expressions.info/ruby.html Regular expressions] 
[http://en.wikipedia.org/wiki/Interactive_Ruby_Shell Interactive Ruby Browser] 
[http://www.ruby-doc.org/core-1.9.2/Array.html Array class in Ruby] 
[http://www.rubyist.net/~slagell/ruby/strings.html String] 
[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] 
[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash class in Ruby] 
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Blocks, Procs and Lambdas] 

[http://www.csc.ncsu.edu/faculty/efg/517/f11/schedule CSC517 Class notes]

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-15T00:33:47Z

Vsuresw: /* Dynamic Typing */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 reflective], [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented], [http://en.wikipedia.org/wiki/Interpreted_language single-pass interpreted] programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports [http://en.wikipedia.org/wiki/Functional_programming functional], [http://en.wikipedia.org/wiki/Imperative_programming imperative], reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like Java and C++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than [http://www.perl.org/ Perl] and more Object Oriented than [http://www.python.org/ Python].
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller MVC] based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. [http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Purely object oriented]'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. [http://c2.com/cgi/wiki?DynamicTyping Dynamically typed]'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Blocks and Closures]'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. [http://www.rubyist.net/~slagell/ruby/iterators.html Built in Iterators]'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. [http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Multiple Inheritance through Mixins]'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. [http://en.wikipedia.org/wiki/Duck_typing Unbounded Polymorphism - "Duck Typing"]'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection]'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. [http://www.regular-expressions.info/ruby.html Syntax level Perl compatible for regular expressions]'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. [http://designpatternsinruby.com/ Built-in support for certain Design Patterns]'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. [http://corelib.rubyonrails.org/classes/GC.html Mark-and-Sweep garbage collection]'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. [http://www.ruby-doc.org/core-1.9.2/Thread.html OS independent threading]'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. [http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Easy interface to C modules]'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. [http://www.ruby-lang.org/en/about/ Portable easily]'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the [http://en.wikipedia.org/wiki/Interactive_Ruby_Shell IRB]. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by [http://www.eclipse.org/ Eclipse]. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

[http://www.jetbrains.com/ruby/ RubyMine] is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object. [http://rubylearning.com/satishtalim/writing_own_ruby_methods.html This] is really helpful to learn more about methods in Ruby.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called [http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing].

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array
 
[http://www.sitepoint.com/typing-versus-dynamic-typing/ Here] is something we got off the internet which explains Dynamic typing well altough its not particular to Ruby.

==Arrays==

An [http://www.ruby-doc.org/core-1.9.2/Array.html array] in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Strings==

A [http://www.rubyist.net/~slagell/ruby/strings.html String] in Ruby may be double-quoted ("...") or single-quoted ('...').

However, double-quoting and single-quoting have different effects in some cases. A double-quoted string allows character escapes by a leading backslash, and the evaluation of embedded expressions using #{}. A single-quoted string does not interpret this. This is shown in the example below:

string1 = "abc"
>> "abc"

string2 = 'efg'
>> "efg"

puts "a\nb\nc"
>>a
>>b
>>c
>>nil

puts 'a\nb\n'
>>a\nb\nc
>>nil

puts "abcd #{5*3} efg"
>>"abcd 15 efg"

puts var = " abc "
>>" abc "
puts "1234#{var}5678"
>>"1234 abc 5678"

Ruby strings can be concatenated using + operator. A string can be repeated multiple times using * operator. The example below shows the use of + and * operators. Ruby string handling is more powerful than C. Since Ruby, provides support for regular expressions, string handling and pattern matching can be made very efficiently and easily.

puts "foo" + "bar"
>>"foobar"

puts "foo" * 2
>>"foofoo"

===Symbols===

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] in Ruby are Strings, just with an important difference, Symbols are immutable while Strings are not. Mutable objects can be changed after assignment while immutable objects can only be overwritten. Ruby is quite unique in offering mutable Strings, which adds greatly to its expressiveness. However mutable Strings can have their share of issues in terms of creating unexpected results and reduced performance. It is for this reason Ruby also offers programmers the choice of Symbols.

Symbols need not contain only alphanumeric characters, by using quotes you can not only use the same characters as you would in a String, but also interpolate Symbols as well. Syntactically, a Symbol needs a colon : prepended. Symbols are actually so similar to Strings that converting between the two is very simple and consistent.

"hello"
:hello

"hello world"
:"hello world"

bang = "!"

"hello world#{bang}" # => "hello world!"
:"hello world#{bang}" # => :"hello world!"

==Hashes==

[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash] is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Block] is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
This example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you don't have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambdas in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

[http://www.rubyist.net/~slagell/ruby/iterators.html Iterator] is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closure] in Ruby is a block that closes over. Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

[http://en.wikipedia.org/wiki/Currying Currying] is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
[http://en.wikipedia.org/wiki/Interpreted_language Interpreted language] 
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection] 
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic language] 
[http://www.python.org/ Python] 
[http://www.perl.org/ Perl] 
[http://rubyonrails.org/ Ruby on Rails] 
[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model View Controller - MVC] 
[http://pragprog.com/book/ppmetr/metaprogramming-ruby Metaprogramming Ruby: Program Like the Ruby Pros] 
[http://designpatternsinruby.com/ Design Patterns in Ruby] 
[http://corelib.rubyonrails.org/classes/GC.html Garbage Collection in Ruby] 
[http://www.ruby-doc.org/core-1.9.2/Thread.html Threads in Ruby] 
[http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Ruby interface to C modules] 
[http://en.wikipedia.org/wiki/Currying Currying]

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
[http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Object Oriented Ruby] 
[http://www.skorks.com/ www.skorks.com] 
[http://www.ruby-lang.org/en/about/ Features of Ruby] 
[http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing] 
[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closures] 
[http://www.rubyist.net/~slagell/ruby/iterators.html Iterators in Ruby] 
[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] 
[http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Modules and Mixins] 
[http://en.wikipedia.org/wiki/Duck_typing Duck Typing - Unbounded Polymorphism] 
[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] 
[http://www.regular-expressions.info/ruby.html Regular expressions] 
[http://en.wikipedia.org/wiki/Interactive_Ruby_Shell Interactive Ruby Browser] 
[http://www.ruby-doc.org/core-1.9.2/Array.html Array class in Ruby] 
[http://www.rubyist.net/~slagell/ruby/strings.html String] 
[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] 
[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash class in Ruby] 
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Blocks, Procs and Lambdas] 

[http://www.csc.ncsu.edu/faculty/efg/517/f11/schedule CSC517 Class notes]

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-15T00:23:05Z

Vsuresw: /* Functions */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 reflective], [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented], [http://en.wikipedia.org/wiki/Interpreted_language single-pass interpreted] programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports [http://en.wikipedia.org/wiki/Functional_programming functional], [http://en.wikipedia.org/wiki/Imperative_programming imperative], reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like Java and C++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than [http://www.perl.org/ Perl] and more Object Oriented than [http://www.python.org/ Python].
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller MVC] based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. [http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Purely object oriented]'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. [http://c2.com/cgi/wiki?DynamicTyping Dynamically typed]'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Blocks and Closures]'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. [http://www.rubyist.net/~slagell/ruby/iterators.html Built in Iterators]'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. [http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Multiple Inheritance through Mixins]'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. [http://en.wikipedia.org/wiki/Duck_typing Unbounded Polymorphism - "Duck Typing"]'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection]'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. [http://www.regular-expressions.info/ruby.html Syntax level Perl compatible for regular expressions]'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. [http://designpatternsinruby.com/ Built-in support for certain Design Patterns]'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. [http://corelib.rubyonrails.org/classes/GC.html Mark-and-Sweep garbage collection]'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. [http://www.ruby-doc.org/core-1.9.2/Thread.html OS independent threading]'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. [http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Easy interface to C modules]'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. [http://www.ruby-lang.org/en/about/ Portable easily]'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the [http://en.wikipedia.org/wiki/Interactive_Ruby_Shell IRB]. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by [http://www.eclipse.org/ Eclipse]. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

[http://www.jetbrains.com/ruby/ RubyMine] is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object. [http://rubylearning.com/satishtalim/writing_own_ruby_methods.html This] is really helpful to learn more about methods in Ruby.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called [http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing].

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array

==Arrays==

An [http://www.ruby-doc.org/core-1.9.2/Array.html array] in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Strings==

A [http://www.rubyist.net/~slagell/ruby/strings.html String] in Ruby may be double-quoted ("...") or single-quoted ('...').

However, double-quoting and single-quoting have different effects in some cases. A double-quoted string allows character escapes by a leading backslash, and the evaluation of embedded expressions using #{}. A single-quoted string does not interpret this. This is shown in the example below:

string1 = "abc"
>> "abc"

string2 = 'efg'
>> "efg"

puts "a\nb\nc"
>>a
>>b
>>c
>>nil

puts 'a\nb\n'
>>a\nb\nc
>>nil

puts "abcd #{5*3} efg"
>>"abcd 15 efg"

puts var = " abc "
>>" abc "
puts "1234#{var}5678"
>>"1234 abc 5678"

Ruby strings can be concatenated using + operator. A string can be repeated multiple times using * operator. The example below shows the use of + and * operators. Ruby string handling is more powerful than C. Since Ruby, provides support for regular expressions, string handling and pattern matching can be made very efficiently and easily.

puts "foo" + "bar"
>>"foobar"

puts "foo" * 2
>>"foofoo"

===Symbols===

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] in Ruby are Strings, just with an important difference, Symbols are immutable while Strings are not. Mutable objects can be changed after assignment while immutable objects can only be overwritten. Ruby is quite unique in offering mutable Strings, which adds greatly to its expressiveness. However mutable Strings can have their share of issues in terms of creating unexpected results and reduced performance. It is for this reason Ruby also offers programmers the choice of Symbols.

Symbols need not contain only alphanumeric characters, by using quotes you can not only use the same characters as you would in a String, but also interpolate Symbols as well. Syntactically, a Symbol needs a colon : prepended. Symbols are actually so similar to Strings that converting between the two is very simple and consistent.

"hello"
:hello

"hello world"
:"hello world"

bang = "!"

"hello world#{bang}" # => "hello world!"
:"hello world#{bang}" # => :"hello world!"

==Hashes==

[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash] is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Block] is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
This example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you don't have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambdas in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

[http://www.rubyist.net/~slagell/ruby/iterators.html Iterator] is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closure] in Ruby is a block that closes over. Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

[http://en.wikipedia.org/wiki/Currying Currying] is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
[http://en.wikipedia.org/wiki/Interpreted_language Interpreted language] 
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection] 
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic language] 
[http://www.python.org/ Python] 
[http://www.perl.org/ Perl] 
[http://rubyonrails.org/ Ruby on Rails] 
[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model View Controller - MVC] 
[http://pragprog.com/book/ppmetr/metaprogramming-ruby Metaprogramming Ruby: Program Like the Ruby Pros] 
[http://designpatternsinruby.com/ Design Patterns in Ruby] 
[http://corelib.rubyonrails.org/classes/GC.html Garbage Collection in Ruby] 
[http://www.ruby-doc.org/core-1.9.2/Thread.html Threads in Ruby] 
[http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Ruby interface to C modules] 
[http://en.wikipedia.org/wiki/Currying Currying]

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
[http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Object Oriented Ruby] 
[http://www.skorks.com/ www.skorks.com] 
[http://www.ruby-lang.org/en/about/ Features of Ruby] 
[http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing] 
[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closures] 
[http://www.rubyist.net/~slagell/ruby/iterators.html Iterators in Ruby] 
[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] 
[http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Modules and Mixins] 
[http://en.wikipedia.org/wiki/Duck_typing Duck Typing - Unbounded Polymorphism] 
[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] 
[http://www.regular-expressions.info/ruby.html Regular expressions] 
[http://en.wikipedia.org/wiki/Interactive_Ruby_Shell Interactive Ruby Browser] 
[http://www.ruby-doc.org/core-1.9.2/Array.html Array class in Ruby] 
[http://www.rubyist.net/~slagell/ruby/strings.html String] 
[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] 
[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash class in Ruby] 
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Blocks, Procs and Lambdas] 

[http://www.csc.ncsu.edu/faculty/efg/517/f11/schedule CSC517 Class notes]

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-15T00:22:16Z

Vsuresw: /* Functions */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 reflective], [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented], [http://en.wikipedia.org/wiki/Interpreted_language single-pass interpreted] programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports [http://en.wikipedia.org/wiki/Functional_programming functional], [http://en.wikipedia.org/wiki/Imperative_programming imperative], reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like Java and C++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than [http://www.perl.org/ Perl] and more Object Oriented than [http://www.python.org/ Python].
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller MVC] based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. [http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Purely object oriented]'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. [http://c2.com/cgi/wiki?DynamicTyping Dynamically typed]'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Blocks and Closures]'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. [http://www.rubyist.net/~slagell/ruby/iterators.html Built in Iterators]'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. [http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Multiple Inheritance through Mixins]'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. [http://en.wikipedia.org/wiki/Duck_typing Unbounded Polymorphism - "Duck Typing"]'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection]'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. [http://www.regular-expressions.info/ruby.html Syntax level Perl compatible for regular expressions]'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. [http://designpatternsinruby.com/ Built-in support for certain Design Patterns]'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. [http://corelib.rubyonrails.org/classes/GC.html Mark-and-Sweep garbage collection]'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. [http://www.ruby-doc.org/core-1.9.2/Thread.html OS independent threading]'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. [http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Easy interface to C modules]'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. [http://www.ruby-lang.org/en/about/ Portable easily]'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the [http://en.wikipedia.org/wiki/Interactive_Ruby_Shell IRB]. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by [http://www.eclipse.org/ Eclipse]. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

[http://www.jetbrains.com/ruby/ RubyMine] is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object.[http://rubylearning.com/satishtalim/writing_own_ruby_methods.html This] is really helpful to learn more about methods in Ruby.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called [http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing].

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array

==Arrays==

An [http://www.ruby-doc.org/core-1.9.2/Array.html array] in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Strings==

A [http://www.rubyist.net/~slagell/ruby/strings.html String] in Ruby may be double-quoted ("...") or single-quoted ('...').

However, double-quoting and single-quoting have different effects in some cases. A double-quoted string allows character escapes by a leading backslash, and the evaluation of embedded expressions using #{}. A single-quoted string does not interpret this. This is shown in the example below:

string1 = "abc"
>> "abc"

string2 = 'efg'
>> "efg"

puts "a\nb\nc"
>>a
>>b
>>c
>>nil

puts 'a\nb\n'
>>a\nb\nc
>>nil

puts "abcd #{5*3} efg"
>>"abcd 15 efg"

puts var = " abc "
>>" abc "
puts "1234#{var}5678"
>>"1234 abc 5678"

Ruby strings can be concatenated using + operator. A string can be repeated multiple times using * operator. The example below shows the use of + and * operators. Ruby string handling is more powerful than C. Since Ruby, provides support for regular expressions, string handling and pattern matching can be made very efficiently and easily.

puts "foo" + "bar"
>>"foobar"

puts "foo" * 2
>>"foofoo"

===Symbols===

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] in Ruby are Strings, just with an important difference, Symbols are immutable while Strings are not. Mutable objects can be changed after assignment while immutable objects can only be overwritten. Ruby is quite unique in offering mutable Strings, which adds greatly to its expressiveness. However mutable Strings can have their share of issues in terms of creating unexpected results and reduced performance. It is for this reason Ruby also offers programmers the choice of Symbols.

Symbols need not contain only alphanumeric characters, by using quotes you can not only use the same characters as you would in a String, but also interpolate Symbols as well. Syntactically, a Symbol needs a colon : prepended. Symbols are actually so similar to Strings that converting between the two is very simple and consistent.

"hello"
:hello

"hello world"
:"hello world"

bang = "!"

"hello world#{bang}" # => "hello world!"
:"hello world#{bang}" # => :"hello world!"

==Hashes==

[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash] is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Block] is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
This example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you don't have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambdas in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

[http://www.rubyist.net/~slagell/ruby/iterators.html Iterator] is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closure] in Ruby is a block that closes over. Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

[http://en.wikipedia.org/wiki/Currying Currying] is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
[http://en.wikipedia.org/wiki/Interpreted_language Interpreted language] 
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection] 
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic language] 
[http://www.python.org/ Python] 
[http://www.perl.org/ Perl] 
[http://rubyonrails.org/ Ruby on Rails] 
[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model View Controller - MVC] 
[http://pragprog.com/book/ppmetr/metaprogramming-ruby Metaprogramming Ruby: Program Like the Ruby Pros] 
[http://designpatternsinruby.com/ Design Patterns in Ruby] 
[http://corelib.rubyonrails.org/classes/GC.html Garbage Collection in Ruby] 
[http://www.ruby-doc.org/core-1.9.2/Thread.html Threads in Ruby] 
[http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Ruby interface to C modules] 
[http://en.wikipedia.org/wiki/Currying Currying]

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
[http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Object Oriented Ruby] 
[http://www.skorks.com/ www.skorks.com] 
[http://www.ruby-lang.org/en/about/ Features of Ruby] 
[http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing] 
[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closures] 
[http://www.rubyist.net/~slagell/ruby/iterators.html Iterators in Ruby] 
[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] 
[http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Modules and Mixins] 
[http://en.wikipedia.org/wiki/Duck_typing Duck Typing - Unbounded Polymorphism] 
[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] 
[http://www.regular-expressions.info/ruby.html Regular expressions] 
[http://en.wikipedia.org/wiki/Interactive_Ruby_Shell Interactive Ruby Browser] 
[http://www.ruby-doc.org/core-1.9.2/Array.html Array class in Ruby] 
[http://www.rubyist.net/~slagell/ruby/strings.html String] 
[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] 
[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash class in Ruby] 
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Blocks, Procs and Lambdas] 

[http://www.csc.ncsu.edu/faculty/efg/517/f11/schedule CSC517 Class notes]

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-15T00:21:29Z

Vsuresw: /* Functions */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 reflective], [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented], [http://en.wikipedia.org/wiki/Interpreted_language single-pass interpreted] programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports [http://en.wikipedia.org/wiki/Functional_programming functional], [http://en.wikipedia.org/wiki/Imperative_programming imperative], reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like Java and C++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than [http://www.perl.org/ Perl] and more Object Oriented than [http://www.python.org/ Python].
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller MVC] based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. [http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Purely object oriented]'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. [http://c2.com/cgi/wiki?DynamicTyping Dynamically typed]'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Blocks and Closures]'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. [http://www.rubyist.net/~slagell/ruby/iterators.html Built in Iterators]'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. [http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Multiple Inheritance through Mixins]'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. [http://en.wikipedia.org/wiki/Duck_typing Unbounded Polymorphism - "Duck Typing"]'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection]'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. [http://www.regular-expressions.info/ruby.html Syntax level Perl compatible for regular expressions]'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. [http://designpatternsinruby.com/ Built-in support for certain Design Patterns]'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. [http://corelib.rubyonrails.org/classes/GC.html Mark-and-Sweep garbage collection]'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. [http://www.ruby-doc.org/core-1.9.2/Thread.html OS independent threading]'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. [http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Easy interface to C modules]'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. [http://www.ruby-lang.org/en/about/ Portable easily]'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the [http://en.wikipedia.org/wiki/Interactive_Ruby_Shell IRB]. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by [http://www.eclipse.org/ Eclipse]. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

[http://www.jetbrains.com/ruby/ RubyMine] is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object.[http://rubylearning.com/satishtalim/writing_own_ruby_methods.html,'This'] is really helpful to learn more about methods in Ruby.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called [http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing].

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array

==Arrays==

An [http://www.ruby-doc.org/core-1.9.2/Array.html array] in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Strings==

A [http://www.rubyist.net/~slagell/ruby/strings.html String] in Ruby may be double-quoted ("...") or single-quoted ('...').

However, double-quoting and single-quoting have different effects in some cases. A double-quoted string allows character escapes by a leading backslash, and the evaluation of embedded expressions using #{}. A single-quoted string does not interpret this. This is shown in the example below:

string1 = "abc"
>> "abc"

string2 = 'efg'
>> "efg"

puts "a\nb\nc"
>>a
>>b
>>c
>>nil

puts 'a\nb\n'
>>a\nb\nc
>>nil

puts "abcd #{5*3} efg"
>>"abcd 15 efg"

puts var = " abc "
>>" abc "
puts "1234#{var}5678"
>>"1234 abc 5678"

Ruby strings can be concatenated using + operator. A string can be repeated multiple times using * operator. The example below shows the use of + and * operators. Ruby string handling is more powerful than C. Since Ruby, provides support for regular expressions, string handling and pattern matching can be made very efficiently and easily.

puts "foo" + "bar"
>>"foobar"

puts "foo" * 2
>>"foofoo"

===Symbols===

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] in Ruby are Strings, just with an important difference, Symbols are immutable while Strings are not. Mutable objects can be changed after assignment while immutable objects can only be overwritten. Ruby is quite unique in offering mutable Strings, which adds greatly to its expressiveness. However mutable Strings can have their share of issues in terms of creating unexpected results and reduced performance. It is for this reason Ruby also offers programmers the choice of Symbols.

Symbols need not contain only alphanumeric characters, by using quotes you can not only use the same characters as you would in a String, but also interpolate Symbols as well. Syntactically, a Symbol needs a colon : prepended. Symbols are actually so similar to Strings that converting between the two is very simple and consistent.

"hello"
:hello

"hello world"
:"hello world"

bang = "!"

"hello world#{bang}" # => "hello world!"
:"hello world#{bang}" # => :"hello world!"

==Hashes==

[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash] is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Block] is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
This example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you don't have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambdas in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

[http://www.rubyist.net/~slagell/ruby/iterators.html Iterator] is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closure] in Ruby is a block that closes over. Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

[http://en.wikipedia.org/wiki/Currying Currying] is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
[http://en.wikipedia.org/wiki/Interpreted_language Interpreted language] 
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection] 
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic language] 
[http://www.python.org/ Python] 
[http://www.perl.org/ Perl] 
[http://rubyonrails.org/ Ruby on Rails] 
[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model View Controller - MVC] 
[http://pragprog.com/book/ppmetr/metaprogramming-ruby Metaprogramming Ruby: Program Like the Ruby Pros] 
[http://designpatternsinruby.com/ Design Patterns in Ruby] 
[http://corelib.rubyonrails.org/classes/GC.html Garbage Collection in Ruby] 
[http://www.ruby-doc.org/core-1.9.2/Thread.html Threads in Ruby] 
[http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Ruby interface to C modules] 
[http://en.wikipedia.org/wiki/Currying Currying]

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
[http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Object Oriented Ruby] 
[http://www.skorks.com/ www.skorks.com] 
[http://www.ruby-lang.org/en/about/ Features of Ruby] 
[http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing] 
[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closures] 
[http://www.rubyist.net/~slagell/ruby/iterators.html Iterators in Ruby] 
[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] 
[http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Modules and Mixins] 
[http://en.wikipedia.org/wiki/Duck_typing Duck Typing - Unbounded Polymorphism] 
[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] 
[http://www.regular-expressions.info/ruby.html Regular expressions] 
[http://en.wikipedia.org/wiki/Interactive_Ruby_Shell Interactive Ruby Browser] 
[http://www.ruby-doc.org/core-1.9.2/Array.html Array class in Ruby] 
[http://www.rubyist.net/~slagell/ruby/strings.html String] 
[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] 
[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash class in Ruby] 
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Blocks, Procs and Lambdas] 

[http://www.csc.ncsu.edu/faculty/efg/517/f11/schedule CSC517 Class notes]

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-15T00:21:05Z

Vsuresw: /* Functions */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 reflective], [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented], [http://en.wikipedia.org/wiki/Interpreted_language single-pass interpreted] programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports [http://en.wikipedia.org/wiki/Functional_programming functional], [http://en.wikipedia.org/wiki/Imperative_programming imperative], reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like Java and C++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than [http://www.perl.org/ Perl] and more Object Oriented than [http://www.python.org/ Python].
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller MVC] based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. [http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Purely object oriented]'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. [http://c2.com/cgi/wiki?DynamicTyping Dynamically typed]'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Blocks and Closures]'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. [http://www.rubyist.net/~slagell/ruby/iterators.html Built in Iterators]'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. [http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Multiple Inheritance through Mixins]'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. [http://en.wikipedia.org/wiki/Duck_typing Unbounded Polymorphism - "Duck Typing"]'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. [http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection]'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming]'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. [http://www.regular-expressions.info/ruby.html Syntax level Perl compatible for regular expressions]'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. [http://designpatternsinruby.com/ Built-in support for certain Design Patterns]'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. [http://corelib.rubyonrails.org/classes/GC.html Mark-and-Sweep garbage collection]'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. [http://www.ruby-doc.org/core-1.9.2/Thread.html OS independent threading]'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. [http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Easy interface to C modules]'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. [http://www.ruby-lang.org/en/about/ Portable easily]'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the [http://en.wikipedia.org/wiki/Interactive_Ruby_Shell IRB]. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by [http://www.eclipse.org/ Eclipse]. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

[http://www.jetbrains.com/ruby/ RubyMine] is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object.[http://rubylearning.com/satishtalim/writing_own_ruby_methods.html,This] is really helpful to learn more about methods in Ruby.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called [http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing].

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array

==Arrays==

An [http://www.ruby-doc.org/core-1.9.2/Array.html array] in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Strings==

A [http://www.rubyist.net/~slagell/ruby/strings.html String] in Ruby may be double-quoted ("...") or single-quoted ('...').

However, double-quoting and single-quoting have different effects in some cases. A double-quoted string allows character escapes by a leading backslash, and the evaluation of embedded expressions using #{}. A single-quoted string does not interpret this. This is shown in the example below:

string1 = "abc"
>> "abc"

string2 = 'efg'
>> "efg"

puts "a\nb\nc"
>>a
>>b
>>c
>>nil

puts 'a\nb\n'
>>a\nb\nc
>>nil

puts "abcd #{5*3} efg"
>>"abcd 15 efg"

puts var = " abc "
>>" abc "
puts "1234#{var}5678"
>>"1234 abc 5678"

Ruby strings can be concatenated using + operator. A string can be repeated multiple times using * operator. The example below shows the use of + and * operators. Ruby string handling is more powerful than C. Since Ruby, provides support for regular expressions, string handling and pattern matching can be made very efficiently and easily.

puts "foo" + "bar"
>>"foobar"

puts "foo" * 2
>>"foofoo"

===Symbols===

[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] in Ruby are Strings, just with an important difference, Symbols are immutable while Strings are not. Mutable objects can be changed after assignment while immutable objects can only be overwritten. Ruby is quite unique in offering mutable Strings, which adds greatly to its expressiveness. However mutable Strings can have their share of issues in terms of creating unexpected results and reduced performance. It is for this reason Ruby also offers programmers the choice of Symbols.

Symbols need not contain only alphanumeric characters, by using quotes you can not only use the same characters as you would in a String, but also interpolate Symbols as well. Syntactically, a Symbol needs a colon : prepended. Symbols are actually so similar to Strings that converting between the two is very simple and consistent.

"hello"
:hello

"hello world"
:"hello world"

bang = "!"

"hello world#{bang}" # => "hello world!"
:"hello world#{bang}" # => :"hello world!"

==Hashes==

[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash] is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Block] is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
This example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you don't have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambdas in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

[http://www.rubyist.net/~slagell/ruby/iterators.html Iterator] is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closure] in Ruby is a block that closes over. Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

[http://en.wikipedia.org/wiki/Currying Currying] is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==

[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 
[http://en.wikipedia.org/wiki/Interpreted_language Interpreted language] 
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection] 
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic language] 
[http://www.python.org/ Python] 
[http://www.perl.org/ Perl] 
[http://rubyonrails.org/ Ruby on Rails] 
[http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model View Controller - MVC] 
[http://pragprog.com/book/ppmetr/metaprogramming-ruby Metaprogramming Ruby: Program Like the Ruby Pros] 
[http://designpatternsinruby.com/ Design Patterns in Ruby] 
[http://corelib.rubyonrails.org/classes/GC.html Garbage Collection in Ruby] 
[http://www.ruby-doc.org/core-1.9.2/Thread.html Threads in Ruby] 
[http://geoffgarside.co.uk/2007/05/20/ruby-c-extensions-nested-modules-classes/ Ruby interface to C modules] 
[http://en.wikipedia.org/wiki/Currying Currying]

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
[http://www.tutorialspoint.com/ruby/ruby_object_oriented.htm Object Oriented Ruby] 
[http://www.skorks.com/ www.skorks.com] 
[http://www.ruby-lang.org/en/about/ Features of Ruby] 
[http://c2.com/cgi/wiki?DynamicTyping Dynamic Typing] 
[http://en.wikipedia.org/wiki/Closure_%28computer_science%29 Closures] 
[http://www.rubyist.net/~slagell/ruby/iterators.html Iterators in Ruby] 
[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] 
[http://ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Modules and Mixins] 
[http://en.wikipedia.org/wiki/Duck_typing Duck Typing - Unbounded Polymorphism] 
[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] 
[http://www.regular-expressions.info/ruby.html Regular expressions] 
[http://en.wikipedia.org/wiki/Interactive_Ruby_Shell Interactive Ruby Browser] 
[http://www.ruby-doc.org/core-1.9.2/Array.html Array class in Ruby] 
[http://www.rubyist.net/~slagell/ruby/strings.html String] 
[http://www.robertsosinski.com/2009/01/11/the-difference-between-ruby-symbols-and-strings/ Symbols] 
[http://www.ruby-doc.org/core-1.9.2/Hash.html Hash class in Ruby] 
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Blocks, Procs and Lambdas] 

[http://www.csc.ncsu.edu/faculty/efg/517/f11/schedule CSC517 Class notes]

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-07T02:46:22Z

Vsuresw: /* Blocks */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports functional, imperative, reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like java and c++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called Dynamic Typing.

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array

==Arrays==

An array in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Has is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambdas in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://www.skorks.com/ www.skorks.com] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
CSC517 Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-07T02:42:05Z

Vsuresw: /* Currying */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports functional, imperative, reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like java and c++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called Dynamic Typing.

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array

==Arrays==

An array in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Has is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x). More about currying may be learnt from [http://en.wikipedia.org/wiki/Currying here]. Currying is a very interesting feature and together with closures, it provides a flexibility to ruby at ease which is not easily achievable in java or c++.

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://www.skorks.com/ www.skorks.com] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
CSC517 Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-07T02:35:29Z

Vsuresw: /* Introduction to Ruby */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports functional, imperative, reflective, object oriented and many other programming paradigms. Since Ruby was designed to incorporate the best features of scripting and Object oriented languages, Ruby emerged to be a very powerful language with native support for many features that are not in the 'nature' of other languages like java and c++.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balances functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.
===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called Dynamic Typing.

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array

==Arrays==

An array in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Has is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://www.skorks.com/ www.skorks.com] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
CSC517 Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-07T02:30:30Z

Vsuresw: /* Ruby vs Java */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

__TOC__

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
Here is a little table that highlights the key differences between java and ruby. Many of these exact difference maybe shared by Ruby and other languages like C,C++ etc. 
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing.
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Methods are passed to the objects
| Objects are passed to the methods
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

The ''.rb'' extension is used to save Ruby files. The Ruby programs can be run by the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file. The path to the ruby command is specified here.
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

===Functions===

Functions are defined by the keyword '''def'''. Ruby does not use { } parenthesis to specify scope. Instead, the keyword '''end''' is equivalent to the closing parenthesis.

def fivetimes(i = 5)
i.times do
puts "Ruby"
end
end

fivetimes
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized in the function definition itself. The arguments can be specified without ( ) parentheses. This means parentheses in a function call are optional. We can write ''fivetimes ( 4 )'' or ''fivetimes 4'' .

Function arguments can be aggregated –
def greeting(*names)
puts "Hello #{names.join(', ')}"
end

greeting('Sam', 'Peter', 'Derek')

>>Hello Sam, Peter, Derek

The user need not specify any return value or have an explicit ''return'' for a function.
The last statement in the function is the return value. And all statements return a value. The function may return ''nil''. Here, in Ruby, ''nil'' does not mean ''null''. ''nil'' is also an object.

==Dynamic Typing==

One of the reasons that makes Ruby easier to program is the fact that the programmer need not specify the type for any variable. Variables in Ruby are not given a type. Their “type” depends upon the value assigned to them. This feature of Ruby is called Dynamic Typing.

In the examples below, the variables ''PI'', ''a'', ''b'', ''c'' are not given a type by the programmer. At run time, ''PI'' is assigned type ''float'', ''a'' and ''b'' are assigned type ''int'', and ''c'' is assigned type ''array''.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a ''#'' and run to the end of the line.

Dynamic typing makes many features like unbounded polymorphism, blocks and closures possible. These features are not available in statically typed languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers, strings and arrays are objects.

5.succ
>>6

"changetoupcase".upcase
>>CHANGETOUPCASE

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

[1,3,6,8].class
>>Array

==Arrays==

An array in Ruby is an ordered list of elements. An array can be considered an object of objects. In C, C++, Java, C# and other languages, an array consists of elements of a similar type. In Ruby, there is no such constraint. An array can consist of any object. We can have a single array that has Fixnum, String, Array etc as elements.

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings
d = ['I am string', 4.5, 1000000, [1,2,3,4]] # elements of different type

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array is illustrated below:
b << 4
>>[1, 2, 3, 4]

b << [10,100]
>>[1, 2, 3, 4, [10, 100]]

Array indexes start from zero. Negative indexes count backward. So ''b[‐1]'' refers to the last element of ''b''.
For example, consider the array ''b'' above.

puts b[-1]
>>[10, 100]

puts b[-2]
>>4

puts b[-1][0]
>>10

puts b[-1][1]
>>100

Arrays can also be created using the ''new'' keyword. ''new'' is used to create objects of any type.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Has is a collection of Key-Value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type, not an integer index. Hashes enumerate their values in the order that the corresponding keys were inserted.

Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil.

Ruby has syntax support for hashes. There are three different ways to create a Hashes.

1. Using the keyword '''new'''.

z = Hash.new
z["a"] = 'Hello'
z["b"] = 'Hi'
z["c"] = 'Hey'

puts z['a']
>>Hello

puts z['b']
>>Hi

puts z['c']
>>Hey

2. Using special syntax '''Hash[ ]'''.

numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''

capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==Conclusion==

Ruby is a purely object oriented language that provides easy programming. The features of Ruby have made it a very popular and extensible language.

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://en.wikipedia.org/wiki/Imperative_programming Imperative Programming] 

==References==

[http://www.ruby-doc.org/docs/ProgrammingRuby/ "Programming Ruby - The Pragmatic Programmer's Guide"] 
[http://www.skorks.com/ www.skorks.com] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
CSC517 Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:59:49Z

Vsuresw: /* History */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by [http://en.wikipedia.org/wiki/Yukihiro_Matsumoto Yukihiro "Matz" Matsumoto]. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, [http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html TIOBE programming language popularity index] state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 

==References==

[http://www.skorks.com/ www.skorks.com] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:57:28Z

Vsuresw: /* Introduction to Ruby */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language) Lisp]. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 

==References==

[http://www.skorks.com/ www.skorks.com] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:57:02Z

Vsuresw: /* Introduction to Ruby */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp_(programming_language)(programming language) Lisp]. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 

==References==

[http://www.skorks.com/ www.skorks.com] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:55:58Z

Vsuresw: /* Introduction to Ruby */

=Introduction to Ruby=

[http://en.wikipedia.org/wiki/Ruby Ruby] is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/SmallTalk Smalltalk], [http://en.wikipedia.org/wiki/Eiffel(programming language) Eiffel] and [http://en.wikipedia.org/wiki/Lisp(programming language) Lisp]. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 

==References==

[http://www.skorks.com/ www.skorks.com] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:53:32Z

Vsuresw: /* Blocks */

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=5
puts number
end
=> nil
multiply
=>5

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }
>>8

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }
>>512

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }
>>10

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 

==References==

[http://www.skorks.com/ www.skorks.com] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:50:32Z

Vsuresw: /* References */

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 

==References==

[http://www.skorks.com/ www.skorks.com] 
[http://ruby-doc.org/ ruby-doc] 
[http://tryruby.org/ tryruby] 
Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:50:13Z

Vsuresw:

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 

==References==

[http://www.skorks.com/ www.skorks.com]
[http://ruby-doc.org/ ruby-doc]
[http://tryruby.org/ tryruby]
Class notes

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:50:02Z

Vsuresw: /* References */

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 

==References==

[http://www.skorks.com/ www.skorks.com]
[http://ruby-doc.org/ ruby-doc]
[http://tryruby.org/ tryruby]
Class notes

==External Links==

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:49:25Z

Vsuresw: /* References */

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 

==References==

[http://www.skorks.com/]
[http://ruby-doc.org/]
[http://tryruby.org/]
Class notes

==External Links==

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:43:31Z

Vsuresw: /* See Also */

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html Learn Ruby] 

==Further Reading==

==External Links==

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:43:09Z

Vsuresw: /* See Also */

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming link Object oriented Programming] 
[http://en.wikipedia.org/wiki/Functional_programming link Functional programming] 
[http://rubylearning.com/satishtalim/tutorial.html link Learn Ruby] 

==Further Reading==

==External Links==

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T23:42:48Z

Vsuresw: /* See Also */

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==
[http://en.wikipedia.org/wiki/Object-oriented_programming link Object oriented Programming]
[http://en.wikipedia.org/wiki/Functional_programming link Functional programming]
[http://rubylearning.com/satishtalim/tutorial.html link Learn Ruby]

==Further Reading==

==External Links==

CSC/ECE 517 Fall 2011/ch3 3a av

2011-10-06T07:55:32Z

Vsuresw:

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==

==Further Reading==

==External Links==

CSC/ECE 517 Fall 2011/ch1 2a av

2011-10-06T07:51:56Z

Vsuresw:

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Least Surprise" or "Principle of Least Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro "Matz" Matsumoto. The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }
1
4
9
16
25

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }
1
4
9
16
25

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }
16
25
36
49
64
81
100

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }
4
16
36
64
100
144
196
256
324
400
The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end
=> nil

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end
=> nil

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.
It does something like this.

f(x,y) ==currying==> f'(2,y).

The two was nothing special. The point was to mention that after currying we get back a function with atleast one parameter lesser than the original function. In other words, currying fixes one or more parameters of a function and returns a new function based on the original function. 

This is achieved, again by lambda method, just like closures.

def multiply (x,y)
val = x*y
val
end
=> nil

mulby2 = lambda { |x| multiply(x,2) }
mulby3 = lambda { |x| multiply(x,3) }

mulby2.call 2
=> 4
mulby3.call 2
=> 6

So, one may notice that, currying takes the existing function multiply(x,y) and curries it to form new functions mulby2(x) and mulby3(x).

==See Also==

==Further Reading==

==External Links==

CSC/ECE 517 Fall 2011/ch1 2a av

2011-10-06T07:36:16Z

Vsuresw:

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Lease Surprise" or "Principle of Lease Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro Matsumoto ("Matz"). The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }

The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

Assume we have been delegated the task of writing a method that takes a parameter and multiplies it by 6. We would probably go ahead and do the following. 

def multByThree ( n )
n*6
end

So far so good. But if we are delegated additional tasks to write multiplier functions to multiply by 1,2,3,4,5...,100 it would be a rather boring and tedious job to create 100 functions to the effect. But ruby has a very elegant solution to it. Closures. 

Closure is a function with two additional properties

* It stores the value of all the variables that were in its scope at time of creation.
* It can be passed around as an object.

In layman terms, a closure is a function that returns another function with atleast one less argument.

def multByN ( n )
closure = lambda { |x| n*x }
end

obj = multByN( 4 )
obj.call 5
=> 20

Thus we have created a closure which is C(N,X) = N*X and having passed the parameter 4 on creation, the function F(x) = 4*x is returned by the closure. The ''lambda'' in the closure definition refers to a lambda function, which has its roots in functional programming.
It basically is used to create functions dynamically which is exactly the purpose of a closure as well.

==Currying==

Currying is very similar to closures. It is basically used to create a function by fixing some value. But the difference is that, closures ''create'' and ''return'' lambda functions; while currying takes a normal function, and makes a lambda function out of it.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==See Also==

==Further Reading==

==External Links==

CSC/ECE 517 Fall 2011/ch1 2a av

2011-10-06T06:42:20Z

Vsuresw:

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Lease Surprise" or "Principle of Lease Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro Matsumoto ("Matz"). The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

==Basics==

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

==Dynamic Typing==

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

==Arrays==

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

==Hashes==

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''. 

Now, it is also possible to use blocks with parametrized functions, 

def displayNumber( parameter )
yield( parameter )
end
displayNumber(10){ |num| puts num }

The above can be extended to two or more parameters 

To compare it with other languages, They are similar to the following,
* Anonymous inner classes in Java
* Anonymous functions in Perl
* Lambda's in Python
* Function objects in C++
* Fucntion pointers in C

It is important to note that, since blocks provide a way to modify the way a method behaves in run-time, it is a very important facet of the polymorphism in Ruby.

==Iterators==

Iterator is an object which is used to traverse through a collection of data. It pretty much means the same thing as it does in java. But the tricky part is that, unlike java, iterators are defined in the collection and is simply put to use when the particular iterator is used. 
There are a few iterators in ruby 
* each
* times
* upto and step
* each_index

[1,2,3,4,5].each{ |i| puts i*i }

The above snippet features a block and an iterator which passes the block to each object in the collection. So, the ''i*i'' is passed to all the objects, thus effectively squaring all of them.

5.times{ |i| puts i*i }

So, this effectively produces the same result as the above, but shall be useful when one has to repeat a task for a '''n''' number of times. 
Its quite annoying to always start from the number 1 as in the case of Times iterator. One may wish to start from a number other than 1. For such cases there is the upto iterator.

4.upto(10) { |i| puts i*i }

The above prints the squares of all numbers from 4 to 10. So basically, 'upto' is 'times' iterator, with a lower bound. 

Now in the kinds of situation where we might need to skip a number two as we progress, the 'step' iterator.

2.step(20,2) { |i| puts i*i }

The above piece of code, as you might have guessed, displays the square of all even numbers from 2 to 20, inclusive.

==Closures==

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==See Also==

==Further Reading==

==External Links==

CSC/ECE 517 Fall 2011/ch1 2a av

2011-10-06T05:14:15Z

Vsuresw:

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Lease Surprise" or "Principle of Lease Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro Matsumoto ("Matz"). The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

===Basics===

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

===Dynamic Typing===

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

===Arrays===

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

===Hashes===

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

def multiply
yield(8)
end
multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function. The above is a good example of a block. It is a standalone set of code, that associates itself with the method ''multiply''

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==See Also==

==Further Reading==

==External Links==

CSC/ECE 517 Fall 2011/ch1 2a av

2011-10-06T05:12:09Z

Vsuresw:

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Lease Surprise" or "Principle of Lease Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro Matsumoto ("Matz"). The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

===Basics===

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

===Dynamic Typing===

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

===Arrays===

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

===Hashes===

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

1. def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

2. def multiply
yield(8)
end

multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

multiply{ |input| puts input*input*input }

without having to refer back to the original function.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==See Also==

==Further Reading==

==External Links==

CSC/ECE 517 Fall 2011/ch1 2a av

2011-10-06T05:10:37Z

Vsuresw:

=Introduction to Ruby=

Ruby is a dynamic, reflective, object oriented, single-pass interpreted programming language. Ruby was influenced by Perl, Smalltalk, Eiffel and Lisp. It supports functional, imperative, reflective, object oriented and many other programming paradigms.

Ruby is said to incorporate the "Principle of Lease Surprise" or "Principle of Lease Astonishment".

==History==

Ruby was created in 1993 in Japan, by Yukihiro Matsumoto ("Matz"). The intent of developing Ruby was to have a new language that balance functional programming and iterative programming. Matsumoto has also stated that he wanted a scripting language that was more powerful than Perl and more Object Oriented than Python.(ref)

===Naming===

The terms "Coral" and "Ruby" were the two proposed names for the language. Matsumoto's choose the term "Ruby" because it was one of his colleague’s birthstone.

===Releases and Versions===

Ruby 0.95 was the first public release in 1995. Three more versions were released immediately.

Ruby 1.0 was released in 1996.

Ruby 1.3 was the next release in 1999.

Since then several versions of Ruby have been released with added concepts and features.

The recent stable version is Ruby 1.9.2 which has significant improvements over Ruby 1.8 series.

Currently, Ruby 1.9.3 is under development with a dual-license of Ruby and BSD.

===Ruby on Rails===

With the release of Ruby on Rails in 2005, an MVC based web development framework written in Ruby, the new language gained mass acceptance and became famous.

In 2006, active user groups were formed in the world's major cities and several Ruby related conferences were held, making it one of the most popular and widely acceptable language. In 2007, TIOBE programming language popularity index (link) state Ruby as the 10th most popular language.

==Features==

'''1. Purely object oriented'''

Ruby is a purely object oriented language. There are no primitives. Everything is an object. For example, Integers, Strings, Arrays are all objects.

'''2. Dynamically types'''

Variables in Ruby are not assigned a type. The programmer need not declare the variable with its type before use. The type of the variable is given the type of the value it is assigned. Unlike statically types languages, there is no static compile time type checking in Ruby.

'''3. Blocks and Closures'''

Ruby supports functional programming paradigm by having blocks and closures. Blocks and Closures are explained in detail below.

'''4. Built in Iterators'''

Ruby supports built-in iterators that are used to traverse over a collection. Built-in iterators make programming easier and code shorter.

'''5. Multiple Inheritance through Mixins'''

The disadvantages of multiple inheritance are overcome in Ruby through the use of Modules and Mixins. These are similar to interfaces in Java.

'''6. Unbounded Polymorphism - "Duck Typing"'''

A method can be invoked on a variable whenever the type of object assigned to the variable has that method defined on it.
This means that if the parameter passed to a method supports the methods invoked on it by the called method, then the calls work.
This is unbounded polymorphism, which can only be found in dynamically typed languages.

'''7. Reflection'''

Reflection is referred to be the ability to introspect or examine the aspects of the program from within the program itself. Reflection allows program entities to discover things about themselves through introspection. For example, an object can ask what its methods are, and a class can tell what its ancestors are. Using refection, we can examine particular objects and decide which for their methods to call at run-time, even if the class of the object didn't exist when we first wrote the code. The program can be modified at run-time.

'''8. Metaprogramming'''

Metaprogramming means writing code that writes code. This allows us to modify the behavior of a program at run time. Ruby has several metaprogramming facilities.

'''9. Syntax level Perl compatible for regular expressions'''

Ruby is a scripting as well as programming language. It is strongly influences by Perl and provides Perl compatible regular expression suport.

'''10. Built-in support for certain Design Patterns'''

Ruby also provides support for certain design patterns that programmers can use to solve the recurring design problems.

'''11. Mark-and-Sweep garbage collection'''

Ruby performs automatic mark-and-sweep garbage collection and frees the unreferenced memory. The programmer need not worry about memory management.

'''12. OS independent threading'''

The threading features that Ruby provides are independent of the underlying Operating System. This provides a great deal of flexibility.

'''13. Easy interface to C modules'''

Ruby provides interface to C modules which help programmers integrate C with Ruby.

'''14. Portable easily'''

Ruby was developed on GNU/Linux. It is portable and works on several types of UNIX, DOS, BeOS, OS/2, Mac OS X, Windows 95/98/Me/NT/2000/XP/Vista/7, etc.

==Downloads and Installation==

The main website for Ruby is http://www.ruby-lang.org/en/.

Ruby downloads and installation instructions can be found at http://www.rubylang.org/en/downloads/. Ruby can be installed by either building it from source or by using the one-click Ruby installer for Windows. Using the one-click Rails Installer for Windows, one can install Ruby and Rails together.

One can also use Ruby online at http://www.tryruby.org/.

==Interactive Ruby Browser - IRB==

Once Ruby is installed, code can directly be evaluated using the IRB. IRB is an interactive command-line interpreter which can be used to test code quickly. The result of execution of the code is immediately returned in the IRB.
It can be started in two ways:

1. Directly open the IRB by clicking on the Interactive Ruby icon.

2. In the command prompt, type "irb" to start a new IRB session.

===Other Editors for Ruby===

Ruby is supported by Eclipse. It has an exclusive Ruby perspective. However, the eclipse plug-in for ruby has to be installed.

RubyMine is another Ruby editor which is commonly used for Ruby on Rails - Web development Framework. Rubymine is considered to be the standard platform for developing applications in Ruby on Rails.

===Basics===

Ruby code can be directly evaluated in the Interactive Ruby Browser. The results are immediately returned in the IRB. Ruby code is saved in files with the extension ''.rb'' and can be run by invoking the command ‘'''ruby filename.rb'''’

The files can be made executable on UNIX systems (without typing '''ruby''') by adding the shebang line as the first line in the file
#!/usr/bin/ruby

The “Hello, world” program can be written as
puts “Hello, world!”
>>Hello, world!

Functions are defined by the keyword '''def'''. The keyword '''end''' is equivalent to the closing parenthesis in other languages.

def ruby(i = 5)
i.times do
puts "Ruby"
end
end

ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby
>>Ruby

The arguments to a function can be initialized. Parentheses in a function call are optional. So we can write '''hello ( 4 )''' or '''hello 4''' . Both mean the same.

Function arguments can be aggregated –
def greet(*names)
puts "Hello #{names.join(', ')}"
end

greet('Amy', 'Beth', 'John')

>>Hello Amy, Beth, John

The last statement in the function is the return value. There is no need for an explicit '''return''' . And all statements return a value.

===Dynamic Typing===

Variables in Ruby are not given a type. Their “type” depends upon the
value assigned to them.

PI = 3.14159 #By convention, constants have uppercase names
a = 5
b = 23
c = [1,1,2,3,5,8] #This is an array declaration

Comments in Ruby start with a '''#''' and run to the end of the line. Dynamic typing makes many features possible, such as unbounded
polymorphism and blocks, which are not available in statically typed
languages such as Java and C++.

Everything is an object since Ruby is purely object-oriented. Even numbers and strings are objects.

5.succ
>>6

"object".upcase
>>OBJECT

[3,1,4,2].sort
>>[1,2,3,4]

“Ruby”.class
>>String

===Arrays===

An array in Ruby is an ordered list of elements. Simple examples illustrate the use of arrays:

a = [] # empty array
b = [1, 2, 3] # array of FixNums
c = ['Hello', 'Ruby'] #array of strings

Special syntax to create an array of strings without the quotes:
d = %w{Hello Ruby}

Appending elements to an Array –
b << 4
>>[1, 2, 3, 4]

Array indexes start from zero. Negative indexes count backward. So '''b[‐1]''' refers to the last element of '''b''' .
Arrays can also be created using the '''new''' keyword. '''new''' is used to create objects of any type. More about '''new''' will follow later.

n = Array.new
n << 10
puts n
>> 10

===Hashes===

Ruby has syntax support for hashes. Wondering what’s a “hash”? It's an “array” that can be indexed by arbitrary keys. Hashes can be created in three ways.

1. Using the keyword '''new''' ,
h = Hash.new
h["a"] = 'b'

puts h['a']
>>b

2. Using special syntax '''Hash[ ]''' or
numbers = Hash['one', 1, 'two', 2, 'three', 3, 'four', 4]

puts numbers['three']
>>3

3. Using '''{ }'''
capitals = {
"France" => "Paris",
"Russia" => "Moscow",
"Japan" => "Tokyo",
"India" => "New Delhi",
"USA" => "Washington, DC"
}

puts capitals["India"]
>>New Delhi

==Blocks==
Block is just a bunch of code grouped together. They are essentially objects, just like any other in Ruby, i.e They can be passed to other methods and other blocks as values, They take in values depending on the context in which it is used. They are also very useful to make the code more modular. 
For example,

1. def multiply
number=8
puts number
end

It is a simple function that takes one parameter, multiplies it by a constant, display the result. Now, it looks fine. But, in the case when you want to change the '5' to '6', in this method, one has to locate the function and change it. 
But, blocks offer a alternative to that. ''Yield'' is used to transfer the control from the method to a 'block' and back to the function again. 

2. def multiply
yield(8)
end

multiply{ |input| puts input }

Here as soon as the execution reaches yield, it is transferred to the block written later, and does the appropriate action.
Thsis example may not be a convincing example. One may argue that the same can be achieved by delegating the task to another method. But blocks are easier because, you dont have to keep track of the other method.
 
So, you may choose to make the function do,

3. multiply{ |input| puts input*input*input }

without having to refer back to the original function.

==Ruby vs Java ==
{| class="wikitable" border="1"
|-
! Ruby
! Java
|-
| Interpreted language
| Compiled language
|-
| Dynamic Typing
| Static typing.
|-
| Purely OO. Everything is an object
| There are primitives and objects.
|-
| Unbounded Polymorphism
| Inheritances and interfaces used.
|-
| Native support for Regular Expressions
| Not native support; java.util.regex provides it.
|-
| Nil is an object which says there is no object
| Null indicates the absence of objects
|-
| Methods calls are treated as messages at runtime
| Method calls are compiled
|-
| Native support for hashes
| Hashes are suported by Collections framework
|}

==See Also==

==Further Reading==

==External Links==

CSC/ECE 517 Fall 2011/ch1 2a av

2011-10-03T01:08:23Z

Vsuresw:

CSC/ECE 517 Fall 2011/ch3 3a av

2011-09-29T19:29:42Z

Vsuresw:

== Introduction ==
This chapter aims to provide the user a nice and smooth transition to programming in Ruby. This article is written in the stand-point of a user who is already familiar with the general Hows and Whats and Whys of programming in C++ and/or Java. This article also provides numerous code snippets that the user can use to get used to Ruby.

==What is Ruby?==
Ruby is a reflective, dynamically typed, object-oriented and single-pass interpreted language. Lot of Jargon? Hmm... 
'''Reflective - ''' Ruby can modify its behavior at one or more points, based on the input it receives pertaining to that. 
'''Object oriented - ''' Ruby is a purely object oriented language. There are absolutely no primitive data types at all in Ruby. Or in other words, every entity and data type is treated as an object in Ruby. 
'''Dynamically typed - ''' The objects get their data type and behavior only AFTER an assignment has been made into it. In other words, after a variable is ''declared'', it can end up being an object of ''any'' type. 
'''Single pass interpreted - ''' The program is executed line by line after the call is made. This is one of the main reasons for ruby's flexibility.

== Installation ==
In this section we shall focus on installing Ruby on two different platforms, Windows and Linux.

=== Windows ===

For windows all the user needs to do is visit [http://rubyinstaller.org/downloads/ this page] and download the Ruby installer. It is a self extracting executable, so all the user has to do is click and wait!

CSC/ECE 517 Fall 2011/ch3 3a av

2011-09-29T19:28:19Z

Vsuresw:

== Introduction ==
This chapter aims to provide the user a nice and smooth transition to programming in Ruby. This article is written in the stand-point of a user who is already familiar with the general Hows and Whats and Whys of programming in C++ and/or Java. This article also provides numerous code snippets that the user can use to get used to Ruby.

==What is Ruby?==
Ruby is a reflective, dynamically typed, object-oriented and single-pass interpreted language. Lot of Jargon? Hmm...
'''Reflective - ''' Ruby can modify its behavior at one or more points, based on the input it receives pertaining to that.
'''Object oriented - ''' Ruby is a purely object oriented language. There are absolutely no primitive data types at all in Ruby. Or in other words, every entity and data type is treated as an object in Ruby.
'''Dynamically typed - ''' The objects get their data type and behavior only AFTER an assignment has been made into it. In other words, after a variable is ''declared'', it can end up being an object of ''any'' type.
'''Single pass interpreted - ''' The program is executed line by line after the call is made. This is one of the main reasons for ruby's flexibility.

== Installation ==
In this section we shall focus on installing Ruby on two different platforms, Windows and Linux.

=== Windows ===

For windows all the user needs to do is visit [http://rubyinstaller.org/downloads/ this page] and download the Ruby installer. It is a self extracting executable, so all the user has to do is click and wait!

CSC/ECE 517 Fall 2011/ch3 3a av

2011-09-29T19:08:16Z

Vsuresw: