Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:52:01Z

Sthirum: /* Duck Typing in Ruby */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a [http://en.wikipedia.org/wiki/Type_system#Static_typing statically typed], multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamically typed], interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A [http://en.wikipedia.org/wiki/Class_(computer_programming) class] is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of [http://en.wikipedia.org/wiki/Duck_typing#In_Ruby “Duck-typing”]. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” <ref name="Duck typing">[http://en.wikipedia.org/wiki/Duck_typing DuckTyping]</ref>. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution<ref>[http://docs.python.org/glossary.html#term-duck-typing Python Duck-typing]</ref>.
In Python, functions like [http://docs.python.org/library/functions.html#type type()] or [http://docs.python.org/library/functions.html#isinstance isinstance()] is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using [http://docs.python.org/library/functions.html#hasattr hasattr()].

Example for duck typing in Python is where Python uses a [http://docs.python.org/library/pickle.html “pickle”] module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.<ref name="example">[http://www.remyroy.com/2008/06/01/duck-typing-and-python/ Ducktyping example in Python]</ref>

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and [http://boo.codehaus.org/Duck+Typing Boo] support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:51:09Z

Sthirum: /* Duck Typing in Python */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a [http://en.wikipedia.org/wiki/Type_system#Static_typing statically typed], multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamically typed], interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A [http://en.wikipedia.org/wiki/Class_(computer_programming) class] is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” <ref name="Duck typing">[http://en.wikipedia.org/wiki/Duck_typing DuckTyping]</ref>. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution<ref>[http://docs.python.org/glossary.html#term-duck-typing Python Duck-typing]</ref>.
In Python, functions like [http://docs.python.org/library/functions.html#type type()] or [http://docs.python.org/library/functions.html#isinstance isinstance()] is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using [http://docs.python.org/library/functions.html#hasattr hasattr()].

Example for duck typing in Python is where Python uses a [http://docs.python.org/library/pickle.html “pickle”] module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.<ref name="example">[http://www.remyroy.com/2008/06/01/duck-typing-and-python/ Ducktyping example in Python]</ref>

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and [http://boo.codehaus.org/Duck+Typing Boo] support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:49:59Z

Sthirum: /* Duck Typing in other languages */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a [http://en.wikipedia.org/wiki/Type_system#Static_typing statically typed], multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamically typed], interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A [http://en.wikipedia.org/wiki/Class_(computer_programming) class] is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” <ref name="Duck typing">[http://en.wikipedia.org/wiki/Duck_typing DuckTyping]</ref>. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution<ref>[http://docs.python.org/glossary.html#term-duck-typing Python Duck-typing]</ref>.
In Python, functions like [http://docs.python.org/library/functions.html#type type()] or [http://docs.python.org/library/functions.html#isinstance isinstance()] is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using [http://docs.python.org/library/functions.html#hasattr hasattr()].

Example for duck typing in Python is where Python uses a [http://docs.python.org/library/pickle.html “pickle”] module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and [http://boo.codehaus.org/Duck+Typing Boo] support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:46:22Z

Sthirum: /* Object oriented languages: An Overview */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a [http://en.wikipedia.org/wiki/Type_system#Static_typing statically typed], multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamically typed], interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A [http://en.wikipedia.org/wiki/Class_(computer_programming) class] is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” <ref name="Duck typing">[http://en.wikipedia.org/wiki/Duck_typing DuckTyping]</ref>. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution<ref>[http://docs.python.org/glossary.html#term-duck-typing Python Duck-typing]</ref>.
In Python, functions like [http://docs.python.org/library/functions.html#type type()] or [http://docs.python.org/library/functions.html#isinstance isinstance()] is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using [http://docs.python.org/library/functions.html#hasattr hasattr()].

Example for duck typing in Python is where Python uses a [http://docs.python.org/library/pickle.html “pickle”] module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:44:42Z

Sthirum: /* Classes: */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A [http://en.wikipedia.org/wiki/Class_(computer_programming) class] is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” <ref name="Duck typing">[http://en.wikipedia.org/wiki/Duck_typing DuckTyping]</ref>. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution<ref>[http://docs.python.org/glossary.html#term-duck-typing Python Duck-typing]</ref>.
In Python, functions like [http://docs.python.org/library/functions.html#type type()] or [http://docs.python.org/library/functions.html#isinstance isinstance()] is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using [http://docs.python.org/library/functions.html#hasattr hasattr()].

Example for duck typing in Python is where Python uses a [http://docs.python.org/library/pickle.html “pickle”] module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:43:34Z

Sthirum: /* Duck Typing in Python */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” <ref name="Duck typing">[http://en.wikipedia.org/wiki/Duck_typing DuckTyping]</ref>. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution<ref>[http://docs.python.org/glossary.html#term-duck-typing Python Duck-typing]</ref>.
In Python, functions like [http://docs.python.org/library/functions.html#type type()] or [http://docs.python.org/library/functions.html#isinstance isinstance()] is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using [http://docs.python.org/library/functions.html#hasattr hasattr()].

Example for duck typing in Python is where Python uses a [http://docs.python.org/library/pickle.html “pickle”] module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:43:05Z

Sthirum: /* Duck Typing in Python */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” <ref name="Duck typing">[http://en.wikipedia.org/wiki/Duck_typing DuckTyping]</ref>. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution<ref>[http://docs.python.org/glossary.html#term-duck-typing Python Duck-typing]</ref>.
In Python, functions like [http://docs.python.org/library/functions.html#type type()] or [http://docs.python.org/library/functions.html#isinstance isinstance()] is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using [http://docs.python.org/library/functions.html#hasattr hasattr()].

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:40:59Z

Sthirum: /* Duck Typing in Python */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” <ref name="Duck typing">[http://en.wikipedia.org/wiki/Duck_typing DuckTyping]</ref>. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution<ref>[http://docs.python.org/glossary.html#term-duck-typing Python Duck-typing]</ref>.
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:39:53Z

Sthirum: /* Duck Typing in Ruby */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” <ref name="Duck typing">[http://en.wikipedia.org/wiki/Duck_typing DuckTyping]</ref>. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:38:44Z

Sthirum: /* Attributes and accessor methods: */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:37:26Z

Sthirum: /* Java: */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects.[http://www.jvoegele.com/software/langcomp.html] For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:35:32Z

Sthirum: /* C++: */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance] which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:34:25Z

Sthirum: /* Comparison of object Oriented Languages */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.<ref name="comparisonOOP">[http://www.jvoegele.com/software/langcomp.html Programming Language Comparison]</ref>

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:32:36Z

Sthirum: /* Object oriented languages: An Overview */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
[http://en.wikipedia.org/wiki/Java_(programming_language) Java] is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
[http://en.wikipedia.org/wiki/Ruby_language Ruby] is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:30:23Z

Sthirum: /* Introduction */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of [http://en.wikipedia.org/wiki/Duck_typing duck typing] in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:28:55Z

Sthirum: /* Introduction */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf OOP in Ruby], CSC 517 Lecture5</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:27:39Z

Sthirum: /* Introduction */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf], CSC 517 Lecture5 - OOP in Ruby</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:26:10Z

Sthirum: /* Introduction */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">CSC 517 Lecture5 - OOP in Ruby</ref> [http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf] of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:25:21Z

Sthirum: /* Introduction */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name="CSC517">CSC 517 Lecture5 - OOP in Ruby</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:22:59Z

Sthirum: /* Introduction */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref>{{Cite web|url=http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf |title=CSC 517 OOP in Ruby}}</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:20:34Z

Sthirum: /* Introduction */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name=OOP517>{{Cite web|url=http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf |title=CSC 517 OOP in Ruby}}</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:19:12Z

Sthirum: /* References */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 <ref name=OOP>{{Cite web|url=http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf |title=CSC 517 OOP in Ruby}}</ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

==References==
<references />

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:17:25Z

Sthirum: /* References */

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:15:38Z

Sthirum: /* References */

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:15:08Z

Sthirum: /* Duck Typing in other languages */

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T19:14:31Z

Sthirum: /* Introduction */

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T18:35:43Z

Sthirum: /* Introduction */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5<ref>http://courses.ncsu.edu/csc517//common/lectures/notes/lec5.pdf </ref> of CSC 517 covered topics of [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] in [http://www.ruby-lang.org/en/ Ruby]. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Inheritance_(computer_science)inheritance] and [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism].

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T18:26:22Z

Sthirum: /* C++: */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 of CSC 517 covered topics of object oriented programming in Ruby. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like encapsulation, data abstraction, inheritance and polymorphism.

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect called [http://en.wikipedia.org/wiki/Diamond_problem Diamond problem].

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T17:09:09Z

Sthirum: /* Python: */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 of CSC 517 covered topics of object oriented programming in Ruby. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like encapsulation, data abstraction, inheritance and polymorphism.

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect.

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control in the form of public, private or protected variables. It has different security mechanisms. However, it allows to emulate protected member by using the prefix '_' before the name and private member by the use of the prefix '__' (double underscore) before the name.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T16:49:58Z

Sthirum: /* Access Control: */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 of CSC 517 covered topics of object oriented programming in Ruby. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like encapsulation, data abstraction, inheritance and polymorphism.

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect.

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.
Ex:

class Employee
def initialize(name, age, salary)
@name = name
@age = age
@salary = salary
end

def name
@name
end
def age
@age
end
def salary
@salary
end

public :name
protected :age
private :salary
end

emp = Employee.new('Jack', 25, 2000);
puts emp.name
#puts emp.age #age protected. gives access violation error
#puts emp.salary #salary private

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T16:34:21Z

Sthirum:

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Introduction ==
Lecture 5 of CSC 517 covered topics of object oriented programming in Ruby. Object oriented programming is a paradigm in which real world entities are represented as objects, where each object has its own attributes and set of functions that it can perform. This gives a data structure called an "object" that consists of data fields and operations. This paradigm presents features like encapsulation, data abstraction, inheritance and polymorphism.

This wiki page tries to cover the other OOP languages and their features in a succinct manner and talks about the features of Ruby in detail with examples. We have also tried to compare the various languages in terms of their features to provide a better understanding.

The lecture also covered the concepts of duck typing in Ruby, closures and currying. The latter two have not been included as per the instructions by the instructor.

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect.

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T16:16:51Z

Sthirum: /* Duck Typing in Python */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect.

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==
The following table compares the Properties of some of the well-known Object Oriented Languages.

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====
[[Image:RubyClass.png|thumb|right|280px|'''''Classes in Ruby''''']]

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:====
The only easy way to change an object's state in Ruby is by calling one of its methods. Control access to the methods, and you have controlled access to the object. A good rule of the thumb is never to expose methods that could leave an object in an invalid state.

Ruby gives you three levels of protection:

''Public methods'' can be called by everyone - no access control is enforced. A class's instance methods (these do not belong only to one object; instead, every instance of the class can call them) are public by default; anyone can call them. The initialize method is always private.

''Protected methods'' can be invoked only by objects of the defining class and its subclasses. Access is kept within the family. However, usage of protected is limited.

''Private methods'' cannot be called with an explicit receiver - the receiver is always self. This means that private methods can be called only in the context of the current object; you cannot invoke another object's private methods.

Access control is determined dynamically, as the program runs, not statically. You will get an access violation only when the code attempts to execute the restricted method.

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

=== Duck Typing in Python===

Python also heavily uses duck typing to allow flexibility to programmers. It emphasizes on the interface rather than on the specifc type which allows for polymorphic substitution [link].
In Python, functions like type() or isistance() is used to check for usual methods to match the type of find out if an object is an instance of a particular class. However, in case of duck typing, the focus is on the attribute of that object, so it checks for the presence of a particular attribute in that object using hasattr().

Example for duck typing in Python is where Python uses a “pickle” module to serialize and de-serialize an object. So, we can introduce a new class that creates a “Tape” object. Now, an object of this type can be passed to the pickle module. Python will not differentiate between a file object or a tape object as long as they both have read() and write() methods.

class Tapefile():
“A tape file”
def __init__(self,params):
#various initialization for tape access
pass
def read(len):
#use special methods to access tape
pass
def readline():
#use special methods to read a whole line on tape
pass
def write(value):
#use special methods to write on tape
pass

=== Duck Typing in other languages===

Duck typing is considered to be a feature provided by dynamic languages. C++ as a static language checks for methods by parameter and signature types. Java does not support duck typing either but it is argued that it can be simulated by the use of interfaces. The concept of duck-typing is criticized as it requires the programmer to have a very wide understanding of the source code and that two objects may implement a method in completely different contexts and so it may result in strange errors.

Although duck typing is considered to be a feature of dynamic languages, some static languages like C# and Boo support it by allowing type checking of classes by the compiler to occur at run time.

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-20T16:01:25Z

Sthirum: /* Duck Typing in Ruby */

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-18T23:36:47Z

Sthirum: /* Attributes and accessor methods: */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect.

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:=====
Just like any other o-o programming language, Ruby allows to exercise control over the attributes and methods of a class. Ruby provides 3 levels of protection at instance methods level.
Public:
In this level objects from outside the class can call the method. All methods except initialize are public by default.
Private:
These methods can be call only by the objects of the same class. Initialize methods are private by default.
Protected:
These methods can be called either by objects of the same class or of the class derived from this class.

The methods are given access levels using the following syntax.
Private :method1, :method2

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-18T23:33:45Z

Sthirum: /* Classes: */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect.

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"

==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:=====
Just like any other o-o programming language, Ruby allows to exercise control over the attributes and methods of a class. Ruby provides 3 levels of protection at instance methods level.
Public:
In this level objects from outside the class can call the method. All methods except initialize are public by default.
Private:
These methods can be call only by the objects of the same class. Initialize methods are private by default.
Protected:
These methods can be called either by objects of the same class or of the class derived from this class.

The methods are given access levels using the following syntax.
Private :method1, :method2

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

CSC/ECE 517 Fall 2011/ch3 4b ms

2011-10-18T17:49:39Z

Sthirum: /* Ruby: */

= Lecture 5: Object Oriented Programming in Ruby =

This wiki tries to cover the Object Oriented concepts in ruby.

__TOC__

== Object oriented languages: An Overview ==

==== C++: ====
C++ is a statically typed, multi-paradigm programming language. It supports some features of object-oriented languages like encapsulation, polymorphism and inheritance. It provides access control by specifiers public, private and protected and also allows “friend” classes. C++ allows multiple inheritance which is eliminated in most other programming languages as it allows a class to inherit from more than one base class which results in an ambiguity effect.

==== Java: ====
Java is classified as a statically typed, hybrid object oriented language. Although it provides information hiding, inheritance and polymorphism, it has a few basic types incorporated that are not objects and some of the built-in operators are provided by basic arithmetic and not as messages to objects. [link]. For these reasons, it is not considered to be a “pure” object-oriented language.

Java provides access control and supports private, public and protected access. It also allows to create packages to create and maintain namespaces. Java is designed not to provide multiple inheritance to avoid problems faced in C++. However, it presents a single-rooted hierarchy where “Object” is the ancestor of all classes (seen in Ruby too) and provides interfaces to extend/inherit functionality.

==== Python: ====
Python is a dynamically typed, interpreted, object oriented language. It is argued that Python is not completely object oriented as it does not provide access control.

==== Ruby: ====
Ruby is dynamically typed and highly object-oriented, much more than Java and Python. In Ruby, it is said that “everything is an object”. Every value happens to be an object in Ruby. You may call methods on a string, an integer just like you call on any object in Java. For ex,

(2.1143).size.times{puts “Hello!”}

This example will display “Hello!” six times on your IRB as the size of the parameter "2.1143" is 6.

== Comparison of object Oriented Languages ==

{| class="wikitable sortable" style="font-size: 9pad case0%; text-align: center; width: auto;"
|-
!Language
!Ruby
!Java
!C#
!C++
!Python
!SmallTalk
!Perl
|-
!Object Orientation
|Pure
|Hybrid
|Hybrid
|Hybrid/Multi-Paradigm
|Hybrid
|Pure
|Add-on/Hybrid
|-
!Static/Dynamic Typing
|Dynamic
|Static
|Static
|Static
|Dynamic
|Dynamic
|Dynamic
|-
!Generic Classes
|N/A
|No
|No
|Yes
|N/A
|N/A
|N/A
|-
!Inheritance
|Single Class/Multiple Mixins
|Single Class/Multiple Interface
|Single Class/Multiple Interface
|Multiple
|Multiple
|Single
|Multiple
|-
!Feature Renaming
|Yes
|No
|No
|No
|No
|No
|NO
|-
!Method Overloading
|No
|Yes
|Yes
|Yes
|No
|No
|No
|-
!Operator Overloading
|Yes
|No
|Yes
|Yes
|Yes
|Yes
|Yes
|-
!Class Variables or methods
|Yes
|Yes
|Yes
|Yes
|No
|Yes
|No
|-
!Access Control
|Public, Protected, Private
|Public, Protected, Package, Private
|Public, Protected, Private, Internal, Protected Internal
|Public, Protected, Private, Friends
|Name Mangling
|Protected Data, Public Methods
|None
|}

== Ruby : Purely Object Oriented ==

Ruby is considered to be a purely Object oriented Language, as everything in it is considered to be an object. Unlike Java, even primitives such as characters, punctuation, numbers and strings are treated as objects in Ruby. Ruby was designed to facilitate the enforcement of Object Oriented Methods. Ruby is a Dynamically Typed Language.

=== Object oriented Concepts in ruby: ===

Ruby is a singly rooted Object Oriented Programming language which has all its classes having the same superclass which is the class Object.

==== Classes:====

A class is used to define a blueprint of a data type. It does not contain any data, but it specifies what kind of variables and methods an object of the class will have.
A class in Ruby is defined using the keyword class followed by the classname. The variables and methods are defined within the class definition and the class definition terminates with the end keyword.

For ex:
class Rectangle
def initialize(w,l)
@width, @length = w, l
end
end
Here, the initialize method is used to set the values of the instance variables (@width and @length. The instance variables are the properties of the objects created of this class type. These instance variables can be accessed within the class using an @. These variables can be accessed from outside the class using the accessor methods which are defined inside the class.

In the following case printLength and printWidth are public methods used to access the instance variables from outside the class. These are called accessor methods.
Similarly, to

class Rectangle
# constructor method
def initialize(w,l)
@width, @length = w, l
end

# accessor methods
def printWidth
@width
end

def printLength
@length
end

# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end

end

# create an object
rectagle = Rectangle.new(10, 20)

# use accessor methods
x = rectangle.printWidth()
y = rectangle.printLength()

puts "Width of the Rectangle is : #{x}"
puts "Length of the Rectangle is : #{y}"
==== Class Methods and Class Variables:====
A class variable is shared between all instances of the class. The value of the class variable remains the same for all the objects of the class. A class variable is accessed within the class using two @ signs at the beginning of the variable name. The class variables must be initialized within the class.

The class methods are defined using def self.methodname() and ends with an end delimiter. These methods are called using the class name itself, for example: classname.methodname

=== Attributes and accessor methods: ===

Every class in Ruby defines a set of attributes for its objects. Ruby provides accessor methods (famously known as getter-setter methods in Java) to access these variables. Ruby provides three kinds of accessor methods:

Class Car
attr_accessor : name, company
attr_reader: price
attr_writer: color
end

attr_accessor creates a setter and getter method. The attr_reader method creates only the getter method. This is required in case of attributes that are not to be modified by other programs but their value may be viewed. The attr_writer creates the setter method. In case of Java, the setter and getter methods need to be written in 3 lines of code each whereas in Ruby, the methods are written just by specifying the type of accessor, which have already been coded using Metaprogramming.[link]

==== Access Control:=====
Just like any other o-o programming language, Ruby allows to exercise control over the attributes and methods of a class. Ruby provides 3 levels of protection at instance methods level.
Public:
In this level objects from outside the class can call the method. All methods except initialize are public by default.
Private:
These methods can be call only by the objects of the same class. Initialize methods are private by default.
Protected:
These methods can be called either by objects of the same class or of the class derived from this class.

The methods are given access levels using the following syntax.
Private :method1, :method2

====Abstract methods====

Ruby is a dynamically typed language and does not provide abstract classes as in Java or C++. It instead provides modules that can be included within any class. The reason why Ruby does not provide abstract classes is because of the idea that it only matters if two objects can perform a function, they don’t necessarily have to be inherited from the same class. This paradigm is provided by modules, where the method of a module can be redefined as required by a class that includes it.

Also, if required the technique of abstract class can be simulated by something like this:

Class Vehicle
def drive
raise NotImplementedError.new("Method not implemented")
end
end

The subclasses that inherit from the above class will have to redefine the method “drive” as required.

=== Duck Typing in Ruby ===

Ruby provides unbounded polymorphism as a dynamically typed language through the concept of “Duck-typing”. “Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface” [link]. This concept is explained by the famous definition as “When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.” This essentially means that in languages like Ruby, it is only checked if an object can implement a function and the type of the object is not taken into consideration. It can be explained better with the help of the following example

class Lion
def roar
puts “The Lion roars when hungry”
end
end

class Person
def roar
puts “The man roared in fury and anger”
end
end

def quality lion
lion.roar
end

def start
leo = Lion.new
jack = Person.new
quality leo
quality jack
end

start

In the above example, leo is an object of class “Lion” and the “roar” method defined in its class is invoked. jack is an object of class “Person” and the corresponding method defined in the Person class is called for him. Although in the real world, both objects are not of the same type, Ruby allows unbounded polymorphism as both of them implement a particular aspect.

Thus, the check for an invoked method is done at run-time in dynamically typed languages and the method defined on that object type is called. If the method is undefined, a “NoMethodError” exception is raised.

CSC/ECE 517 Fall 2011

2011-10-18T03:35:24Z

Sthirum:

[[Link title]]
*[[CSC/ECE 517 Fall 2011/ch1 1a ms]]

*[[CSC/ECE 517 Fall 2011/ch1 1a cs]]

*[[CSC/ECE 517 Fall 2011/ch1 1a ri]]

*[[CSC/ECE 517 Fall 2011/ch1 1a lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1b sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1b ds]]

*[[CSC/ECE 517 Fall 2011/ch1 1b tj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c cm]]

*[[CSC/ECE 517 Fall 2011/ch1 1c sj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c ka]]

*[[CSC/ECE 517 Fall 2011/ch1 1d sr]]

*[[CSC/ECE 517 Fall 2011/ch1 1e vs]]

*[[CSC/ECE 517 Fall 2011/ch1 1e aa]]

*[[CSC/ECE 517 Fall 2011/ch1 1a sc]]

*[[CSC/ECE 517 Fall 2011/ch1 1e dm]]

*[[CSC/ECE 517 Fall 2011/ch1 1e an]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1e lm]]

*[[CSC/ECE 517 Fall 2011/ch1 1g vn]]

*[[CSC/ECE 517 Fall 2011/ch1 1f rs]]

*[[CSC/ECE 517 Fall 2011/ch1 1f sv]]

*[[CSC/ECE 517 Fall 2011/ch1 1g jn]]

*[[CSC/ECE 517 Fall 2011/ch1 1h ps]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sm]]

*[[CSC/ECE 517 Fall 2011/ch1 1i zf]]

*[[CSC/ECE 517 Fall 2011/ch1 1g rn]]

*[[CSC/ECE 517 Fall 2011/ch1 1i cl]]

*[[CSC/ECE 517 Fall 2011/ch1 1d ss]]

*[[CSC/ECE 517 Fall 2011/ch1 1i lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1h hs]]

*[[CSC/ECE 517 Fall 2011/ch1 1d gs]]

*[[CSC/ECE 517 Fall 2011/ch1 2b ns]]

*[[CSC/ECE 517 Fall 2011/ch1 2b jp]]

*[[CSC/ECE 517 Fall 2011/ch1 2a av]]

*[[CSC/ECE 517 Fall 2011/ch2 2f jm]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ad]]

*[[CSC/ECE 517 Fall 2011/ch2 2e kt]]

*[[CSC/ECE 517 Fall 2011/ch2 2e gp]]

*[[CSC/ECE 517 Fall 2011/ch1 2b qu]]

*[[CSC/ECE 517 Fall 2011/ch2 2c bs]]

*[[CSC/ECE 517 Fall 2011/ch1 2c rs]]

*[[CSC/ECE 517 Fall 2011/ch1 2a ca]]

*[[CSC/ECE 517 Fall 2011/ch1 2b rv]]

*[[CSC/ECE 517 Fall 2011/ch2 2c ds]]

*[[CSC/ECE 517 Fall 2011/ch2 2b sa]]

*[[CSC/ECE 517 Fall 2011/ch2 2f vh]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ps]]

*[[CSC/ECE 517 Fall 2011/ch3 3a oe]]

*[[CSC/ECE 517 Fall 2011/ch3 3h rr]]

*[[CSC/ECE 517 Fall 2011/ch3 3h ss]]

*[[CSC/ECE 517 Fall 2011/ch3 4b js]]

*[[CSC/ECE 517 Fall 2011/ch3 4b ms]]

*[[CSC/ECE 517 Fall 2011/ch4 4i aa]]

*[[CSC/ECE 517 Fall 2011/ch4 4i sd]]

*[[CSC/ECE 517 Fall 2011/ch4 4d mt]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ls]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ch]]

*[[CSC/ECE 517 Fall 2011/ch4 4c ap]]

*[[CSC/ECE 517 Fall 2011/ch4 4h sv]]

*[[CSC/ECE 517 Fall 2011/ch4 4e cl]]

*[[CSC/ECE 517 Fall 2011/ch4 4a ga]]

*[[CSC/ECE 517 Fall 2011/ch4 4f sl]]

*[[trial]]

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:45:05Z

Sthirum: /* References */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between? as seen in the following example<ref>http://corelib.rubyonrails.org/classes/Comparable.html </ref>

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, [http://www.java-tips.org/java-se-tips/java.lang/how-to-use-comparable-interface.html comparable functionality] is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. The interface in the following example <ref> http://www.java-tips.org/java-se-tips/java.lang/how-to-use-comparable-interface.html </ref> has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members <ref>http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/</ref>:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==Notes==
<references/>

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:40:24Z

Sthirum: /* Comparable Functionality */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between? as seen in the following example<ref>http://corelib.rubyonrails.org/classes/Comparable.html </ref>

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, [http://www.java-tips.org/java-se-tips/java.lang/how-to-use-comparable-interface.html comparable functionality] is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. The interface in the following example <ref> http://www.java-tips.org/java-se-tips/java.lang/how-to-use-comparable-interface.html </ref> has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members <ref>http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/</ref>:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==Notes==
<references/>

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:37:11Z

Sthirum: /* Enumerable Behaviour */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, [http://www.java-tips.org/java-se-tips/java.lang/how-to-use-comparable-interface.html comparable functionality] is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. The interface in the following example <ref> http://www.java-tips.org/java-se-tips/java.lang/how-to-use-comparable-interface.html </ref> has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members <ref>http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/</ref>:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==Notes==
<references/>

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:32:47Z

Sthirum: /* Comparable Functionality */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, [http://www.java-tips.org/java-se-tips/java.lang/how-to-use-comparable-interface.html comparable functionality] is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. The interface in the following example <ref> http://www.java-tips.org/java-se-tips/java.lang/how-to-use-comparable-interface.html </ref> has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==Notes==
<references/>

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:30:50Z

Sthirum: /* Comparable Functionality */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, [http://www.java-tips.org/java-se-tips/java.lang/how-to-use-comparable-interface.html comparable functionality] is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. This interface has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==Notes==
<references/>

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:26:32Z

Sthirum: /* References */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, comparable functionality is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. This interface has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==Notes==
<references/>

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:25:31Z

Sthirum: /* Module */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, comparable functionality is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. This interface has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==Notes==
<references/>

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:24:49Z

Sthirum:

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/]</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, comparable functionality is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. This interface has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==Notes==
<references/>

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:21:45Z

Sthirum: /* Module */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/]</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, comparable functionality is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. This interface has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:20:11Z

Sthirum: /* Conclusion */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, comparable functionality is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. This interface has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:19:18Z

Sthirum: /* References */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, comparable functionality is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. This interface has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

<references/>
==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:16:37Z

Sthirum: /* Conclusion */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, comparable functionality is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. This interface has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.

==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface

CSC/ECE 517 Fall 2011/ch2 2c bs

2011-10-02T01:14:56Z

Sthirum: /* Using Mixins */

==Introduction==
An [http://en.wikipedia.org/wiki/Interface_(computing) interface] <ref>interface</ref> in the [http://en.wikipedia.org/wiki/Java_(programming_language) Java] programming language is an abstract type that is used to specify an interface that classes must implement. Interface may only contain [http://en.wikipedia.org/wiki/Method_signature method signature] and constant declarations. An interface may never contain method definitions. Interfaces cannot be instantiated. A class that implements an interface must implement all of the methods described in the interface, or be an [http://en.wikipedia.org/wiki/Abstract_type abstract] class. Object references in Java may be specified to be of an interface type; in which case, they must either be null, or be bound to an object that implements the interface.

In object-oriented programming languages, a [http://en.wikipedia.org/wiki/Mixin mixin] <ref> mixin </ref> is a class that provides a certain functionality to be inherited or just reused by a subclass. Some of the functionality of mixins is provided by interfaces in popular languages like Java and [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#]. However, an interface only specifies what the class must support and cannot provide an implementation. Another class, providing an implementation and dependent with the interface, is needed for [http://en.wikipedia.org/wiki/Code_refactoring refactoring] common behavior into a single place. Interfaces combined with aspect-oriented programming can produce full-fledged mixins in languages that support such features, such as C# or Java.
One benefit of using interfaces is that they simulate [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. All classes in Java other than [https://matrix.senecac.on.ca:8443/wiki/javaSE/index.php/Java.lang.Object java.lang.Object], must have exactly one base class; multiple inheritance of classes is not allowed.

==Overview==
===Mixins in Ruby===
In Java you just have [http://en.wikipedia.org/wiki/Class_(computer_programming) classes] (both abstract and concrete) and interfaces. The [http://en.wikipedia.org/wiki/Ruby Ruby] language provides classes,[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html modules], and a mix of both. Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance. A mixin can also be viewed as an interface with implemented methods. When a class includes a mixin, the class implements the interface and includes, rather than inherits, all the mixins’ attributes (fields, properties) and methods. They become part of the class during compilation. A mixin can defer definition and binding of methods until runtime, though attributes and instantiation parameters are still defined at compile time. In the Ruby language a mixin is a class that is mixed with a module.

====Module====

A [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html module]<ref>module</ref> is a degenerate abstract class. A module can’t be instantiated and no class can directly extend it but it can fully implement methods. A class can leverage the implementation of a module by including the module’s methods. A module can define methods that can be shared in different and separate classes either at the class or instance level.We can view an example <ref> http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/</ref> module that converts a numeric value to its English word.

# Convert a integer value to English.
module Stringify
# Requires an instance variable @value
def stringify
if @value == 1
"One"
elsif @value == 2
"Two"
elsif @value == 3
"Three"
end
end
end

The Stringify module above makes use of a @value [http://en.wikipedia.org/wiki/Instance_variable instance variable]. The class that will be mixed with this module needs to define and set a @value instance variable since the Stringify module uses it but does not define it. In addition to instance variables a module could invoke methods not defined in the module but in the class that it will be mixed with.

A [http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Self contained module] can also be written in Ruby where the methods defined in a module can be used as static methods independent of their implementation within a class.

'''Self Contained Module Example: '''

# A Math module akin to Java Math class.
module Math
# Could be called as a class, static, method
def add(val_one, val_two)
BigInteger.new(val_one + val_two)
end
end

The methods in the Math module are intended to be invoked like class methods, also known as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods static] methods. The add method in the Math module accepts two integer values and returns an [http://en.wikipedia.org/wiki/Instance_(computer_science) instance] of BigInteger.

====Using Mixins====

Implementation of the class and module are joined, interwined, combined, etc. A mixin is a different mechanism to the extend construct used to add concrete implementation to a class. With a mixin you can extend from a module instead of a class.

The example of self-contained module shows how the method returns a BigInteger sum after accepting two integer parameters. The following example is the implementation of BigInteger class. The BigInteger class defines one constructor and directly inherits one method from the Number base class. To mix in the methods implemented in the Stringify and Math modules with the BigInteger class you will note the usage of the include and extend methods, respectively.

# Base Number class
class Number
def intValue
@value
end
end

# BigInteger extends Number
class BigInteger < Number

# Add instance methods from Stringify
include Stringify

# Add class methods from Math
extend Math

# Add a constructor with one parameter
def initialize(value)
@value = value
end
end

Using the class:

# Create a new object
bigint1 = BigInteger.new(10)
# Call a method inherited from the base class
puts bigint1.intValue # --> 10

The extend method will mix a module’s methods at the class level. The method defined in the Math module can be used as a class/static method.

# Call class method extended from Math
bigint2 = BigInteger.add(-2, 4)
puts bigint2.intValue # --> 2

The include method will mix a module’s methods at the instance level, meaning that the methods will become instance methods. The method defined in the Stringify module can be used as an instance method.

# Call a method included from Stringify
puts bigint2.stringify # --> 'Two'

There is another use of the extend method. You can enhance an object instance by mixing it with a module at run time. This ‘CurrencyFormatter’ is used to extend an object, changing it’s responsibilities at runtime.

# Format a numeric value as a currency
module CurrencyFormatter
def format
"$#{@value}"
end
end

To mix an object instance with a module you can do the following:

# Add the module methods to
# this object instance, only!
bigint2.extend CurrencyFormatter
puts bigint2.format # --> '$2'

Calling the extend method on an instance will only extend that one object; objects of the same class will not be extended with the new functionality.

puts bigint1.format # will generate an error

Modules that will be mixed with a class via the include or extend method could define something like a constructor or initializer method to the module. The module initializer method will be invoked at the time the module is mixed with a class. When a class extends a module the module’s self.extended method will be invoked:

module Math
def self.extended(base)
# Initialize module.
end
end

The self prefix indicates that the method is a static module level method. The base parameter in the static extended method will be either an instance object or class object of the class that extended the module depending whether you extend a object or class, respectively.
When a class includes a module the module’s self.included method will be invoked.

module Stringify
def self.included(base)
# Initialize module.
end
end

The base parameter will be a class object for the class that includes the module.
It is important to note that inside the included and extended initializer methods you can include and extend other modules.

module Stringify
def self.included(base)
base.extend SomeOtherModule
end
end

===Interfaces in Java===
Interfaces define a standardized set of commands that a class will obey. The commands are a set of methods that a class implements. The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method. Example:
interface Bicycle {
void changeCadence(int newValue); // wheel revolutions per minute
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

Implementation is independent to each class that implements the interface. Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface. Implementing an interface enables a class to be "plugged in" in any situation that requires a specific behavior (manifested through the set of methods).

class ACMEBicycle implements Bicycle {
//implementation specific to this class
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

class MOUNTAINBicycle implements Bicycle {
int cadence = 2;
int speed = 3;
int gear = 5;
void changeCadence(int newValue) {
cadence = newValue + 10;
}
void changeGear(int newValue) {
gear = newValue + 4;
}
void speedUp(int increment) {
speed = speed + increment + 10;
}
void applyBrakes(int decrement) {
speed = speed – decrement – 10;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class. In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.
You could then reference one of these objects with either an A reference or a B reference. Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

==Mixins vs Interfaces==
Because of this mixin feature, a developer can add arbitrary methods and modify behavior of core classes at runtime. This is amazingly powerful if you are trying to write plugins and extensions to the [http://en.wikipedia.org/wiki/Software_framework framework]. Because you can add functionality to existing objects, users can install their [http://en.wikipedia.org/wiki/Plug-in_(computing) plugin] and start taking advantage of new functionality without having to make changes to the objects that they are instantiating in their application.

In frameworks written in other languages, such as Java, plugging in new functionality means that you need to change how your objects are instantiated. This will require code changes and/or potentially configuration changes which makes it hard to develop, hard to maintain, and a pain for plugin developers to support. But because of the mixin feature, Rails plugin developers can customize the base objects and the users of the plugins do not have to change any of their code or configuration logic.

===Differences===

These is a general comparision:

{| class="wikitable"
|-
! Mixins in Ruby
! Interfaces in Java
|-
| 'include' or 'extend' keywords used to include the module in the class.
| 'implement' keyword is used to implement interface

|-
| Need not implement the module methods in the class.
| Should implement the interface methods.

|-
| The methods are not copied into the class in which they are included. They are referenced.
| The methods’ implementation is in the class itself.

|-
| The included method definition is decided at ‘run time’. If the definition changes while running the function points to the changed code.
| The definition is known compile time and will not change until the code is compiled and run again.

|-
| Modules inclusion does not provide a superclass and subclass relationship.
| Interface extending provides a superclass and subclass relationship.

|-
| When we use mixins we included only a module of the class.
| We include the entire interface class.

|-
| Mainly for code reuse and does not provide any hierarchy.
| It provides a hierarchy.

|}

===Functionality and Behavior Comparison===
The functionality and behavior of Mixins in Ruby is compared with Interfaces in Java

====Comparable Functionality====
Sometime we are required to compare the class members of different objects of the same class and/or sort them. This is the comparable functionality that we are trying to achieve for a given class. This functionality can be achieved by both the Ruby using mixins and Java using interfaces. There is not much difference using both.

'''Ruby'''

The [http://www.ruby-doc.org/core/classes/Comparable.html Comparable] mixin is used by classes whose objects may be ordered. The class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

class SizeMatters
include Comparable
attr :str
def <=>(anOther)
str.size <=> anOther.str.size
end
def initialize(str)
@str = str
end
def inspect
@str
end
end

''using class:''

s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")

''output:''
s1 < s2 #=> true
s4.between?(s1, s3) #=> false
s4.between?(s3, s5) #=> true
[ s3, s2, s5, s4, s1 ].sort #=> [Z, YY, XXX, WWWW, VVVVV]

'''Java'''

In Java, comparable functionality is achieved by extending the “Comparable” interface. List of objects that implement this interface can be sorted automatically by sort method of the list interface. This interface has compareTo() method that is used by the sort() method of the list. Here compareTo() method can also be used to compare two objects with respect to the implementation in compareTo() implementation in the derived class. It returns ‘0’ , ‘1’ and ‘-1’ corresponding to whether one is equal to , greater than or lesser than other.
In this example code Employee class is implementing Comparable interface and have method compareTo().
public class Employee implements Comparable {
int EmpID;
String Ename;
double Sal;
static int i;
public Employee() {
EmpID = i++;
Ename = "dont know";
Sal = 0.0;
}
public Employee(String ename, double sal) {
EmpID = i++;
Ename = ename;
Sal = sal;
}
public String toString() {
return "EmpID " + EmpID + "\n" + "Ename " + Ename + "\n" + "Sal" + Sal;
}
public int compareTo(Object o1) {
if (this.Sal == ((Employee) o1).Sal)
return 0;
else if ((this.Sal) > ((Employee) o1).Sal)
return 1;
else
return -1;
}
}

ComparableDemo.java is showing the use of this interface. This class first makes a list of objects of type Employee and call sort method of java.util.Collections, which internally uses compareTo() method of Employee class and sort the list accordingly.

import java.util.*;
public class ComparableDemo{
public static void main(String[] args) {
List ts1 = new ArrayList();
ts1.add(new Employee ("Tom",40000.00));
ts1.add(new Employee ("Harry",20000.00));
ts1.add(new Employee ("Maggie",50000.00));
ts1.add(new Employee ("Chris",70000.00));
Collections.sort(ts1);
Iterator itr = ts1.iterator();
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}
}

''Output:''

EmpID 1
Ename Harry
Sal 20000.0
EmpID 0
Ename Tom
Sal 40000.0
EmpID 2
Ename Maggie
Sal 50000.0
EmpID 3
Ename Chris
Sal 70000.0

====Singleton Behaviour====

A [http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a class guaranteed to have only a single instance, with a single global access point to that instance. It can be implemented in Ruby and Java. In Ruby we can include a module to acquire all the functionality of the singleton module. The code is already there and we are just reusing the code and adding that similar functionality into our class. Here our intention is to add the functionality of singleton to the class which is achieved using mixins. In java, implementation of interfaces means that the class which implements the interface becomes a type of that class, which is not the intention here. So, there is not interface which class can implement to get the functionality in itself. It has to implement the functionality itself without implementing any interface.

'''Ruby'''

When you include the singleton method inside your class it makes the new method private so that you cannot use it. Including ‘singleton’ adds a class method called instance that instantiates only one instance of the class

# require singleton lib
require 'singleton'
class AppConfig
# mixin the singleton module
include Singleton
# do the actual app configuration
def load_config(file)
# do your work here
puts "Application configuration file was loaded from file: #{file}"
end
end

''output:''

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml" #=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2 #=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!) #=> new method is private

====Enumerable Behaviour====
This [http://www.ruby-doc.org/core/classes/Enumerable.html enumerable] functionality adds support to the array members of the class. We can achieve this functionality using mixins in Ruby while it is not possible to do it in Java using interfaces.

'''Implementation in Ruby:'''

It adds the functionality of map, inject, select etc to the class which includes the ‘Enumerable’ module. The class which includes should represent a collection of items. Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerable methods rely on this.
Example:
This is a Team class that manages a group of members:

class Team
include Enumerable
attr_accessor :members
def initialize
@members = []
end
def each &block
@members.each{|member| block.call(member)}
end
end

Enumerable requires that your class contain an each method that serves up the items in the collection. All the other Enumerablemethods rely on this. Now we can use the map method, for instance:

team = Team.new
team.members = ['joshua', 'gabriel', 'jacob']
team.map{|member| member.capitalize} # => ["Joshua", "Gabriel", "Jacob"]

Now we can call any Enumerable methods on our team object itself, and it will assume we want to work with the members array within.

====Data Mapper Behaviour====

[http://datamapper.org/docs/ DataMapper] is an API which comes with the ability to use the same API to talk to a multitude of different datastores. There are adapters for the usual RDBMS suspects, NoSQL stores, various file formats and even some popular webservices. This is implemented in ruby using mixins. We need not use interfaces to implement.

'''Implementation in Ruby:'''
class Post
include DataMapper::Resource
property :id, Serial
end

==Conclusion==
The point to take away from this is not that Ruby Mixins are more powerful than Java Interfaces. The mixin feature of Ruby allows for the development of easy to use but powerful plugins that will be hard for any non-Ruby based framework to compete with. Java has many other ways of implementing the functionality mixins are capable of. It is just that it does not use Interfaces to achieve the functionality. Even though both of them are a way of achieving multiple inheritance in their respective languages, they achieve quiet different goals. Inheritance in Java is mainly to overcome the confusion which arises with multiple inheritance, while Mixins in Ruby is mainly to add an additional functionality to the existing class apart from the ‘primary functionality’ of the class.

When a class implements Interface, it indicates that it is of the type interface class and forms a hierarchy with the interface class, while ruby mixins are mainly intended for code reuse and including an additional functionality to the class. It does not form any hierarchy as it is only using module of the class.
<references/>
==References==
* http://en.wikipedia.org/wiki/Interface_(Java)
* http://en.wikipedia.org/wiki/Mixin
* http://carboni.ca/blog/p/Modules-How-Do-They-Work
* http://rubylearning.com/satishtalim/modules_mixins.html
* http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/
* http://www.innovationontherun.com/why-rubys-mixins-gives-rails-an-advantage-over-java-
* http://datamapper.org/
* http://www.dsource.org/projects/tutorials/wiki/SingletonPattern
* http://corelib.rubyonrails.org/classes/Comparable.html
* http://kconrails.com/2010/11/30/ruby-enumerable-primer-part-1-the-basics/
* http://stackoverflow.com/questions/575920/is-a-ruby-module-equivalent-to-a-java-interface