Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-21T00:07:39Z

Abalasu3: /* When "extends" is more useful than Cloning */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.

It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
[http://docs.selflanguage.org/langref.html slots]. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

==''When "extends" is more useful than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.

We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

[http://docs.selflanguage.org/langref.html Slots]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-21T00:05:59Z

Abalasu3: /* Cloning */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.

It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
[http://docs.selflanguage.org/langref.html slots]. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

==''When "extends" is more useful than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language. 
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

[http://docs.selflanguage.org/langref.html Slots]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-21T00:03:41Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.

It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
[http://docs.selflanguage.org/langref.html slots]. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

==''When "extends" is more useful than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language. 
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

[http://docs.selflanguage.org/langref.html Slots]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-21T00:03:18Z

Abalasu3: /* Cloning */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.

It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
[http://docs.selflanguage.org/langref.html slots]. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

==''When "extends" is more useful than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language. 
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-21T00:00:40Z

Abalasu3: /* Cloning */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.

It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

==''When "extends" is more useful than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language. 
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-21T00:00:10Z

Abalasu3: /* When "extends" is more useful than Cloning */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is more useful than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language. 
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:59:48Z

Abalasu3: /* When "extends" is more useful than Cloning */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is more useful than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language. 
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:59:26Z

Abalasu3: /* When "extends" is more useful than Cloning */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is more useful than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language. 
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:59:02Z

Abalasu3: /* When "extends" is more useful than Cloning */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is more useful than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language. 
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:58:09Z

Abalasu3: /* When "extends" is better than Cloning */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is more useful than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:57:55Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming] 

[http://en.wikipedia.org/wiki/Cloning_(programming) Cloning]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:57:29Z

Abalasu3: /* Prototype based Languages in Brief */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of [http://en.wikipedia.org/wiki/Cloning_(programming) cloning] (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:56:27Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://en.wikipedia.org/wiki/Self_(programming_language) Self Programming]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:51:37Z

Abalasu3: /* Prototype based Languages */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages in Brief''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 

==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:51:10Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] 

[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:49:19Z

Abalasu3: /* Implementation of Code Reuse: */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as [http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance].
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby]

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:47:53Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html Extends in Ruby]

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly What makes Ruby Powerful?] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General] 

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming] 

[http://docs.python.org/tutorial/classes.html Inheritance in Python]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:43:15Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly Extends in Ruby] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance in General]

[http://en.wikipedia.org/wiki/Prototype-based_programming Prototype based Programming]

[http://coweb.cc.gatech.edu]

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:42:24Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#] 

[http://www.tenouk.com/Module14.html Inheritance in C++] 

[http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly Extends in Ruby] 

[http://helephant.com/2009/08/17/javascript-prototype-chaining Java Script Prototype Chaining] 

[[#References|[6]]]http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming

[[#References|[7]]]http://en.wikipedia.org/wiki/Prototype-based_programming

[[#References|[8]]]http://coweb.cc.gatech.edu

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:40:35Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx Extends in C#]

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

[[#References|[6]]]http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming

[[#References|[7]]]http://en.wikipedia.org/wiki/Prototype-based_programming

[[#References|[8]]]http://coweb.cc.gatech.edu

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:40:17Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://xahlee.org/java-a-day/extend.html Extends in Java] 

[http://msdn.microsoft.com/en-us/library/bb383977.aspx]

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

[[#References|[6]]]http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming

[[#References|[7]]]http://en.wikipedia.org/wiki/Prototype-based_programming

[[#References|[8]]]http://coweb.cc.gatech.edu

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:39:45Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://xahlee.org/java-a-day/extend.html Extends in Java]
[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

[[#References|[6]]]http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming

[[#References|[7]]]http://en.wikipedia.org/wiki/Prototype-based_programming

[[#References|[8]]]http://coweb.cc.gatech.edu

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:39:16Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[http://xahlee.org/java-a-day/extend.html]
[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

[[#References|[6]]]http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming

[[#References|[7]]]http://en.wikipedia.org/wiki/Prototype-based_programming

[[#References|[8]]]http://coweb.cc.gatech.edu

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:38:31Z

Abalasu3: /* When extends are better than Cloning */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When "extends" is better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

[[#References|[6]]]http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming

[[#References|[7]]]http://en.wikipedia.org/wiki/Prototype-based_programming

[[#References|[8]]]http://coweb.cc.gatech.edu

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:38:00Z

Abalasu3: /* Comparison of "Extend property " in Prototype Based languages to Class Based Languages. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When extends are better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

[[#References|[6]]]http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming

[[#References|[7]]]http://en.wikipedia.org/wiki/Prototype-based_programming

[[#References|[8]]]http://coweb.cc.gatech.edu

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:37:39Z

Abalasu3: /* Comparison of "Extend property " in Prototype Based languages to Class Based Languages. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==
We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When extends are better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

[[#References|[6]]]http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming

[[#References|[7]]]http://en.wikipedia.org/wiki/Prototype-based_programming

[[#References|[8]]]http://coweb.cc.gatech.edu

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T23:35:52Z

Abalasu3: /* Comparison of "Extend property " in Prototype languages to Class Based Languages. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype Based languages to Class Based Languages.=

==''Prototype based Languages''==
Prototype-based programming is a kind of object-oriented programming in which there are no classes, and behavior
reuse is performed through the process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 
==''Cloning''==

We saw how the extend key word is used in Java, C#, and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 
==''When extends are better than Cloning''==
Just like any other style, Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

[[#References|[6]]]http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming

[[#References|[7]]]http://en.wikipedia.org/wiki/Prototype-based_programming

[[#References|[8]]]http://coweb.cc.gatech.edu

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:59:33Z

Abalasu3: /* References */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype languages to Class Based Languages.=


Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 


We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

[[#References|[6]]] http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:58:15Z

Abalasu3: /* Implementation of Code Reuse: */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

[http://en.wikipedia.org/wiki/Inheritance_in_object-oriented_programming Inheritance] is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or multiple classes, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype languages to Class Based Languages.=


Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 


We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:51:00Z

Abalasu3: /* Comparison of "Extend property " in Prototype languages to Class Based Languages. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

=Comparison of "Extend property " in Prototype languages to Class Based Languages.=


Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 


We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:50:13Z

Abalasu3: /* Comparison of Extend methods in Java, C# and Ruby. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=


Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 


We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:49:51Z

Abalasu3: /* Comparison of Extend methods in Java, C# and Ruby. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''In C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=


Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 


We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:49:19Z

Abalasu3: /* In java: */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''Java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''In C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''In C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''In Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''In Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=


Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 


We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:49:03Z

Abalasu3: /* Comparison of Extend methods in Java, C# and Ruby. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''In java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

=='''''In C#:'''''==

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''In C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''In Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''In Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=


Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 


We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:48:42Z

Abalasu3: /* Comparison of Extend methods in Java, C# and Ruby. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''In java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

'''''In C#:'''''

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

=='''''In C++'''''==

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

=='''''In Python:'''''==

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

=='''''In Ruby:'''''==

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=


Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 


We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:47:59Z

Abalasu3: /* Comparison of Extend methods in Java, C# and Ruby. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

=='''''In java:'''''==

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

'''''In C#:'''''

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

'''''In C++'''''

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

'''''In Python:'''''

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

'''''In Ruby:'''''

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=


Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 


We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:47:18Z

Abalasu3: /* Comparison of "Extend property " in Prototype languages to Class Based Languages. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

'''''In java:'''''

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

'''''In C#:'''''

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

'''''In C++'''''

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

'''''In Python:'''''

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

'''''In Ruby:'''''

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=


Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
 


We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
 

Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.


=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:46:38Z

Abalasu3: /* How Extending Objects in Ruby is more powerful than other languages */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

'''''In java:'''''

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

'''''In C#:'''''

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

'''''In C++'''''

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

'''''In Python:'''''

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

'''''In Ruby:'''''

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

 The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=

<pre>
Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
</pre>
<pre>

We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
</pre>
<pre>
Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.
</pre>

=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:46:20Z

Abalasu3: /* Comparison of Extend methods in Java, C# and Ruby. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

'''''In java:'''''

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

'''''In C#:'''''

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

'''''In C++'''''

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}
void display()
cout<<x<<y;
}
}
class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

'''''In Python:'''''

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

'''''In Ruby:'''''

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=

<pre>
Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
</pre>
<pre>

We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
</pre>
<pre>
Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.
</pre>

=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:45:49Z

Abalasu3: /* Comparison of Extend methods in Java, C# and Ruby. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

'''''In java:'''''

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}
void Show(){
System.out.println(x);
}
}
class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}
void display(){
System.out.println("Child");
}
}
</code>

'''''In C#:'''''

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

'''''In C++'''''

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}

void display()
cout<<x<<y;
}
}

class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

'''''In Python:'''''

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

'''''In Ruby:'''''

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=

<pre>
Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
</pre>
<pre>

We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
</pre>
<pre>
Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.
</pre>

=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:45:19Z

Abalasu3: /* Comparison of Extend methods in Java, C# and Ruby. */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

'''''In java:'''''

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}

void Show(){
System.out.println(x);
}
}

class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}

void display(){
System.out.println("Child");
}
}
</code>

'''''In C#:'''''

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type. 
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
 The above example shows how to call the standard query operator OrderBy method on an array of integers.

'''''In C++'''''

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}

void display()
cout<<x<<y;
}
}

class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

'''''In Python:'''''

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

'''''In Ruby:'''''

 The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=

<pre>
Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
</pre>
<pre>

We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
</pre>
<pre>
Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.
</pre>

=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:43:58Z

Abalasu3: /* Implementation of Code Reuse: */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

'''''In java:'''''

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}

void Show(){
System.out.println(x);
}
}

class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}

void display(){
System.out.println("Child");
}
}
</code>

'''''In C#:'''''

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type.
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
The above example shows how to call the standard query operator OrderBy method on an array of integers.

'''''In C++'''''

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}

void display()
cout<<x<<y;
}
}

class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

'''''In Python:'''''

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

'''''In Ruby:'''''

The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=

<pre>
Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
</pre>
<pre>

We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
</pre>
<pre>
Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.
</pre>

=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:43:35Z

Abalasu3: /* Introduction */

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

 One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

'''''In java:'''''

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}

void Show(){
System.out.println(x);
}
}

class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}

void display(){
System.out.println("Child");
}
}
</code>

'''''In C#:'''''

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type.
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
The above example shows how to call the standard query operator OrderBy method on an array of integers.

'''''In C++'''''

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}

void display()
cout<<x<<y;
}
}

class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

'''''In Python:'''''

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

'''''In Ruby:'''''

The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=

<pre>
Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
</pre>
<pre>

We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
</pre>
<pre>
Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.
</pre>

=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:42:16Z

Abalasu3:

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

'''''In java:'''''

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

<code>
class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}

void Show(){
System.out.println(x);
}
}

class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}

void display(){
System.out.println("Child");
}
}
</code>

'''''In C#:'''''

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type.
<code>
class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
</code>
The above example shows how to call the standard query operator OrderBy method on an array of integers.

'''''In C++'''''

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.
<code>
class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}

void display()
cout<<x<<y;
}
}

class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</code>

'''''In Python:'''''

To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

<code>
class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</code>

'''''In Ruby:'''''

The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

<code>
module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam
</code>

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

<code>
module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</code>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=

<pre>
Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
</pre>
<pre>

We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
</pre>
<pre>
Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.
</pre>

=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-20T00:39:59Z

Abalasu3:

'''''Extending objects.''''' : ''Consider one or more practical examples of Ruby's extend method--that is,
examples that serve a real need and are not contrived. What facilities do other languages have for extending
objects? Are they more or less powerful than Ruby's? Also consider prototype-based languages such as Self,
which don't even provide classes.''
---------------------------
= Introduction=

One of the most fundamental advantages of using Object Orientation is to reuse code. Rather than coding what was already
coded, we can simply extend it to suit the needs of the new class. This helps to develop applications rapidly.
Many languages provide built in libraries which can be included in classes. The O-O languages also provide a way to add
functionality to existing classes through extension.

=Implementation of Code Reuse:=

“Inheritance” is the word used in O-O for the process of inheriting the members of a class and extending the functionality.
A class can inherit from a single class or “Multiple Classes”, the latter is called as “Multiple Inheritance”.
While a child class inherits from the parent class, it tends to inherit all the members of the class.

=Comparison of Extend methods in Java, C# and Ruby.=

'''''In java:'''''

A class declaration can use the extend keyword on another class as follows:
<Code>
Class Course extends College
{
..............
}

</code>
When a class Child extends class Parent, Child automatically has all variables and methods defined in class Parent.
If class Child defines a variable or method that has the same name in class Parent, class Child's definition
overrides that of Parent's.

class Parent {
int x;
int y;
int get(int a, int b){
x=a; y=b; return(0);
}

void Show(){
System.out.println(x);
}
}

class Child extends Parent {
public static void main(String args[]){
Parent p = new Parent();
p.get(5,6);
p.Show();
}

void display(){
System.out.println("Child");
}
}
</pre>

'''''In C#:'''''
<pre>

Extension methods enable the programmer to "add" methods to existing types without creating a new derived type, recompiling,
or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called
as if they were instance methods on the extended type.

class ExtensionMethod
{
static void Main()
{
int[] s = { 1, 55, 75, 93, 81, 96 };
var r = s.OrderBy(g => g);
foreach (var a in result)
{
System.Console.Write(a + " ");
}
}
}

Output:
1 55 15 81 93 96
The above example shows how to call the standard query operator OrderBy method on an array of integers.
</pre>

'''''In C++'''''
<pre>

Similar to Java, C++ also extends functionality of a base class to a derived class. The derived class can use the functions
and variables of a base class as well as add their own functionality, thus making them a more specialized version of the base
class. Similar to Java, overriding is also supported in C++. Here is an example of how a class is extended in C++.

class Base{
public:
int x;
int y;
int get(int a, int b){
x=a;
y=b;
return(0);
}

void display()
cout<<x<<y;
}
}

class derived:public base{
void Main(){
Base b;
b.get(5,6);
b.display();
void display(){
cout<<”Derived”;
}
}
</pre>

'''''In Python:'''''
<pre>
To extend a class in Python, we simply call the parent class in the parenthesis while defining the child class.
This will pass all the methods and variables defined in the parent class to the child class.
An illustration of how classes are extended in python.

class Parent:
a=5
b=4
def add():
print(a+b)
class Child(Parent):
def difference():
print(a-b)
p = Parent()
c = Child()
c.add()
c.difference()
</pre>

'''''In Ruby:'''''
<pre>
The include method effectively adds a module as a super class of self. It is used inside a class definition
to make the instance methods in the module available to instances of the class.
It is sometimes useful to add the instance methods to a particular object.
This is done using Object#extend.

module Write
def pen
"#{self} says use a pen not a pencil for your exam!"
end
end
obj = " Proctor"
obj.extend Write
puts obj.pen

Output: Proctor says use a pen not pencil for your exam

If the extend key word is used within a class definition, the modules methods become class methods.
This is because extend is equal to self.extend, so the methods are added to self, which in a class definition is the class itself.

module Write
def pen
"#{self} says use a pen not pencil for your exam"
end
end
class Proctor
extend Write
end
puts Proctor.pen

Output: Proctor says use a pen not pencil for your exam
</pre>
-----------------

=How Extending Objects in Ruby is more powerful than other languages=

The one main disadvantage of inheriting from a class is that, we tend to inherit all of its members, most of which
we may not use in our programs. Ruby however gives us the option of extending only what we need. Several modules can
be created and these modules can be extended at runtime. The extend keyword makes the module available to all instances
of the class. A class can simply extend the modules and uses it the way it wants on the move. This, however, does not
change the objects original code. This is really a unique and powerful feature of Ruby.

='''Comparison of "Extend property " in Prototype languages to Class Based Languages.'''=

<pre>
Prototype-based programming is a style of object-oriented programming in which classes are not present, and behavior
reuse is performed via a process of cloning (Cloning is the process of making of an exact copy of an object) existing objects
that serve as prototypes. Languages like Self, Newton Script, Slate, Ioke, Io are examples of a prototype language.
Most class-based Object Oriented languages are based on Classes which can be described as defining the basic qualities and
behaviors of objects and object instances which can be described as being manifestations of classes.
In prototype-based languages like Self, the duality between classes and object instances is not needed. There is no need for
having an instance of an object that is based on a class. For example, in Self a copy of an existing object is made, and
then changes are made to it. Basic objects that are used primarily to make copies are known as prototypes. When an existing
object proves to be an insufficient, a programmer can create a modified object with the expected behavior, and use that instead of
the previous one.
</pre>
<pre>

We saw how the extend key word is used in Java, C# and in Ruby. In languages like Self, instead of having a class definition take up
memory, and every instance take up memory, clones of objects generally take up a small amount memory. Every object just points to another object.
So the fewer changes the programmer makes to a clone of an object, the fewer the amounts of new data need to be stored, and thus lesser amount
of memory that a programmer needs to do a new clone. Prototype-based languages will help simplify the understanding of each object.
It is also a fact that languages like Self, make it easier to fix bugs in code. This is because prototype-based languages use the concept of
slots. We are referring to a method as slot because the programmer can change the functionality of any object, by changing a method alone.
When new code is placed into an object's slot the functionality of that object is changed.
Another advantage is that the user interfaces also benefit from the use of prototype-based languages. User interfaces
hold less amount of objects. Objects are created in interfaces for a specific purpose. Without creating many classes for many
purposes, or creating just a few big ones, each of them with a number of methods for implementation, cloning objects is a proved
easier solution.
</pre>
<pre>
Prototype-based programming has its own disadvantages. Consider the cases when repetitive types of data is used like the ones in a database.
Here prototype-based programming would decrease efficiency of these applications. And also in this case, Class-based programming will be best
and perhaps the only solution for these kinds of problems.
We saw that in Java, inheritance is achieved using extends keyword. In Java Script, a prototype based language, Prototype chaining is used
to build new types of objects based on existing ones. The functionality is very similar to inheritance in a class based language.
Constructor functions have a property known as prototype. Adding properties and methods to the prototype property will also adds the
method or property to all objects created by the constructor function. This prototype property is a mere javascript object such that it is
possible to create a function’s prototype using another constructor function. When this is done, all of the properties and methods from
the constructor function’s prototype are automatically added to new the prototype object. This makes it easy to create a constructor function
that builds objects that are just an extended version of an existing one.
</pre>

=References=
[[#References|[1]]]http://xahlee.org/java-a-day/extend.html

[[#References|[2]]]http://msdn.microsoft.com/en-us/library/bb383977.aspx

[[#References|[3]]]http://www.tenouk.com/Module14.html

[[#References|[4]]]http://perfectionlabstips.wordpress.com/2008/11/19/how-to-extend-ruby-object-on-the-fly

[[#References|[5]]]http://helephant.com/2009/08/17/javascript-prototype-chaining.

CSC/ECE 517 Fall 2011/ch4 4a aj

2011-10-18T15:22:19Z

Abalasu3: Created page with "New page"

New page

CSC/ECE 517 Fall 2011/ch1 2b rv

2011-10-01T00:05:30Z

Abalasu3: /* C# */

'''Access Control in O-O Languages

__TOC__

=Introduction to Access control=

In [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming], access control refers to the control of visibility of data and methods. The main idea behind access control is to restrict access to certain parts of the code to external entities. Access control implements [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation] by providing varying levels of access to code. The use of access control becomes necessary in any practical environment where selective access is a key criterion. 
For example, only the instructor can be allowed to modify grades of students but all students should be given access to retrieve and view their respective grades.
Access control in different object oriented languages and the underlying details will be covered in this topic.

=Overview of Access Control Mechanisms=

Each O-O language has a specific implementation of access control mechanisms. However, a plethora of the most widely used o-o languages share similar features while implementing access control. Access control mechanisms are applicable to class members like variables and functions. Some level of access control can be applied at the class level. The 3 basic types of access control implementation which is common to some [http://en.wikipedia.org/wiki/Static-typing_%28programming_languages%29#Static_and_dynamic_typing static and dynamic O-O languages] [like C++, C#, Java and Ruby] are 
 
'''Public''' : Methods or attributes that are declared to be public can be accessed from any class. This is the least restrictive access control method. For example, we may want everyone in a company to know the names of people working along with them. Thus public access is given to employee's name.

'''Private''' : This mechanism makes the data or method to be visible only in the class in which it is declared. The support is not extended to sub classes. This is the most restrictive access control method.
In any application, methods which implement the core functionality or require administrator access are declared to be private thereby enforcing limited access. For example, only a manager can be given the authority to review an employee’s performance and award bonus and promotions.

'''Protected''' : The use of protected access allows access of data and methods to be modified by members belonging to the same family. This means that this support is extended to subclasses. Protected access control can be used to support the single interface, multiple implementation concept i.e, [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inheritance].
For example, a super class may have a protected method called ComputeArea(). We can have many subclasses like Triangle, Rectangle etc inherit the super class and override the method ComputeArea() to provide their own specific implementation. In a more practical scenario, a person might be allowed to view the medical history of immediate family members. However, people outside the family will not be allowed access to view this medical history.

=Implementing Access Control=

Programming languages implement access control in different ways. We present a few of the languages that use access control and show their implementation.

=='''Java'''==
In Java, access control is achieved using the modifiers public, private and protected. If a class is not declared with any modifier, then the default access becomes package-private i.e, any object within the package should be able to access this class.

'''Public Keyword''' – Other classes can modify public fields unless its declared as [http://en.wikipedia.org/wiki/Final_%28Java%29 final]. The syntax for declaring a variable/method public is as follows 
<pre>public int x;
public void print_Hello()</pre>

In the example shown below, the variable studentName is public and hence can be accessed in another class Student2. Similarly, public methods like getName() etc become accessible by other classes. 
'''Private Keyword''' – This keyword makes the class members private. Private members can only be accessed from within the class. They are not visible even in subclasses. However, visibility and access of private members is extended to nested classes. The syntax for declaring a variable/method private is as follows
<pre>private String EmpID;
private void getEmpDetails() </pre>

In the example code below, the method setID is declared to be private. Hence, it cannot be accessed in the subclass of the class Student.

'''Protected Keyword''' – This keyword when used before a class member makes that member visible to the elements residing in that class and its subclasses. The syntax for declaring a variable/method protected is as follows
<pre>protected int sides;
protected void setArea(int sides)</pre>

In the example code below, the method setName is declared as protected. Hence, it can be accessed in the subclass NewStudent.

'''Default access level/Package''' – When no specific access control keyword is given, then the method or variable becomes accessible to all classes under a particular package. In the following example, the integer “packageVar” becomes accessible to all classes included in the package ‘TestPackage1’. Hence, it can be modified in the class Student2.

<pre>

Example:

package TestPackage1
public class Student {

public String studentName;
public int studentID;
int packageVar;

public String getName() {
return studentName;
}
public int getID() {
return studentID;
}
protected void setName(String s) {
studentName = s;
}
private void setID(int y) {
studentID = y;
}
public static void main(String[] args) {
Student Stu1 = new Student();
Stu1.setName("ABCD");
Stu1.setID(1230013);
System.out.println(Stu1.getName() + Stu1.getID());
}
}
public class NewStudent extends Student {
public static void main(String[] args) {
NewStudent NewStu1 = new NewStudent();
NewStu1.setName("EFGH"); //Can be accessed
NewStu1.setID(350); // Cannot be accessed as setID is private
System.out.println(NewStu1.getName());
}
}
public class Student2 {
public static void main(String[] args) {
Student Stu2 = new Student();
Stu2.studentName = "Mickey"; //Public variable of another class can be accessed
Stu2.packageVar = 5; //Default access level
}
}
</pre>

=='''C++==
In C++, we have the three modifiers presented in the overview along with a special type of access control called [http://en.wikipedia.org/wiki/Friend_function friend]. The behavior of public, private and protected modifiers is similar to its Java counterparts.

Friend - A function or class can access the private and protected members of a class if it is declared as a friend of that class. 

<pre>
class Number
{ int a,b;
friend int canAccess(Number numb); // Declaring canAccess() to be a friend
public:
int add(int,int);
protected:
int diff(int,int);
private:
int prod(int,int);

int add(int a,int b)
{
return a+b;
}
int diff(int a,int b)
{
if (a>b)
return a-b;
else
return b-a;
}
int prod(int a,int b)
{
return a*b;
}
};
public static void main()
{
Number num;
int a=10, b=20;
cout << "Sum =" << num.add(a,b);
cout << "Difference =" << num.diff(a,b);
//cout << "Product = " << num.prod(a,b); // this will throw an error if the comments are removed
}

// Friend function
int canAccess(Number numb)
{
cout<< "Product for a friend = " << numb.prod(10,20)
}

</pre>

'''More about friend functions'''

If a class is declared as a friend in another class, the friend class can access all the private members of the class. This can also be limited in such a way that only few private members of the class can be accessed. By using friend functions or classes, we can provide a flexibility of letting a friend class access restricted members of a class and still keeping the restricted members closed for access by any other class. This will be useful in a few cases.

=='''Ruby==
Ruby provides the three levels of access controls, private, public and protected with the default being public access. The behavior of public and protected access control is similar to other languages like C++ and Java.
However, private methods can be called only within the context of the current object. Other object’s private method cannot be invoked. Private methods can be overridden by the sub-classes.In most cases, private methods are used to provide internal functionality to the class. So we need to use a cautious approach in using private methods. If they are overridden by the subclass, we tend to get unexpected behavior in the program.

'''Note''': Private methods cannot be called outside of the class. Private methods can be called only using the “send” method. 

<pre>
class Number
def initialize(a,b)
@number1 = a
@number2 = b
end
def num1
@number1
end
def num2
@number2
end
def add(a)
puts a.num1+a.num2
end
def diff(a)
puts a.num1-a.num2
end
public:add
public:diff
protected:num1
#private:num2
end
Num1=Number.new(50,60)
Num1.add(Num1)
Num1.diff(Num1)
</pre>

This program runs successfully and prints the output as long as the private method is not accessed. Here, the private method is num2 and should not be invoked in the current context of the object.

<pre>in `add': private method `num2' called for #<Number:0x436e18 @number1=50, @number2=60> (NoMethodError)</pre>

However, the private method num2 can be accessed using the send method. The syntax for accessing the method is '''a.send(:num2)

=='''C#==
It has 5 specific levels of access control at the class member level.

'''1. Public''' : Public access is the least restrictive access level and class members can be accessed anywhere. 
'''2. Private''' : Private is the most restrictive access level where members are accessed only in the body of the class in which they are declared. This support is also extended to nested classes. 
'''3. Protected''' : The protected keyword is a member access modifier i.e, it cannot be applied at a class level. A protected member is accessible from within the class in which it is declared, and from within any class derived from the class that declared this member.

<pre>

class Number
{
public int x =5;
public int y =10;
public int add() {
return x+y;
}
protected int diff(){
return y-x;
}
private int prod(){
return x*y;
}
}

class Number1
{
public static void Main()
{
Number num = new Number();
num.add(); //access to add
num.diff(); // can't as diff is declared protected
num.prod(); // can't access as prod is private
}
}

class Number2 : Number
{
public static void Main()
{
Number2 num2 = new Number2();
num2.diff(); // access to protected member
}
}
</pre>

'''4. Internal''' : It is an access modifier for types and type members. Internal members are accessible only within files in the same assembly.
'''5. Protected Internal''': This access control restricts access of members to the class, subclass within the assembly. The difference between protected internal and internal is that, a subclass of the class derived in another assembly can also access the protected internal method.

<pre>
File1.cs:
class Number3
{
internal int x =0;
protected internal int y = 0;
}
File2.cs
class Number4 : Number3
{
public static void Main()
{
Number4 num4 = new Number4();
num4.x = 4 // error, as x is declared as internal
num4.y = 5 // Allowed. As y is protected internal.
}
}
</pre>

=='''Python==
Python implements access control in a different way from most other languages in that they don’t have specific access control modifiers. By default all members are public and we precede the member name with ‘__’ (a double underscore) to indicate if the member is private. This feature of python is called as [http://en.wikipedia.org/wiki/Name_mangling Name Mangling]. 

There is no feature in python to implement the protected access control. 

<pre>
class Number:
def __init(self,a,b): // this is a private method
self.a = a
self.b = b

def add():
print self.a + self.b

def diff():
print self.b - self.a

Num1=Number(50,60)
Num1.add()
Num1.diff()
</pre>

Note that in python the __init method is made to be private as default while programming. 

'''More on Name Mangling in Python
Name mangling is a feature of python using which we indicate whether a member is private by just adding underscores, instead of using key words. When we program or debug, it is easier to note that the member is private and thus refrain from accessing it.

=='''Eiffel==
Eiffel has a different approach to access control compared to the previous object oriented languages like C++ and Java. It uses ''selective export'', which means that different methods and attributes can have different access levels. Also, we can individually specify the access level for each method or attribute.

<pre>
class Number
feature{NONE} -- indicates nothing can access this code from outside of the class (private)
a: INTEGER
b: INTEGER
initialize is
do
a := 10
b := 20
end
end
feature{ANY} -- indicates this method can be accessed from anywhere outside of the class(public)
add: INTEGER is
do
Result := a+b
end
end
feature{Number} -- indicates that this method can be accessed only by members of the class Number
diff: INTEGER is
do
Result := b-a
end
end
</pre>

'''More on feature:
Using feature, we can provide varying levels of access to a code in the class. And also we can provide the names of classes that are only allowed to access that part of the code. In the above example, the different access levels that features provide are explained in the comments.

=Comparison among different O-O languages=

{|class="wikitable"
|-
!
!Java
!C++
!C#
!Ruby
!Python
!Eiffel
|-
|Public
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|-
|Protected
|Access within the class and sub-classes
|Access within the class and subclasses
|Access within the class and subclasses
|Access within the class and subclasses
|No protected access
|Access can be given to only a few of the classes.
|-
|Private
|Cannot be directly accessed from outside the class. Can be accessed by nested classes.
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|-
|Special feature
|Default access is package. Any class in a package can access if no modifier is given
|friend functions(access of private to a specific friend class or method)
|internal and protected internal
|send method is used to access private members
|Name Mangling(use of underscores to indicate access level)
|Selective export using "feature"
|}

=A short note on the usage of Access Control=

With many access control mechanisms defined, there is always the question of which access control can be used. This is decided at the discretion of the programmer but as a good programming practice, the following can be used.

1. Use public access only if an interface for a class so that the data can be sent or modified based on external requirements.
2. Use of private is advisable whenever we program the internal structure of the program, like the constructors. Some languages, like Ruby make their variables private by default so that modifications from external entities are avoided.

=Summary=

Access control provides powerful mechanism to implement encapsulation and it can find its use in several of the applications. However, if not used with caution, access control can lead to unexpected behavior in the program. It is always important to use the right access control for the situation to avoid ambiguity and ease the maintainability of code.

=References=

* [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] 
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation] 
* [http://download.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html Access Control in Java] 
* [http://msdn.microsoft.com/en-us/library/kktasw36(v=VS.80).aspx Member Access Control in C++] 
* [http://www.exforsys.com/tutorials/c-plus-plus/c-plus-plus-friend-functions.html C++ friend functions] 
* [http://en.wikipedia.org/wiki/Friend_function Implementing friend functions] 
* [http://msdn.microsoft.com/en-us/library/ms173121.aspx Access Modifiers in C#] 
* [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_classes.html Programming Ruby] 
* [http://rubylearning.com/satishtalim/ruby_access_control.html Access Control in Ruby] 
* [http://en.wikipedia.org/wiki/Name_mangling Name Mangling in OO Langugages] 
* [http://docs.python.org/release/1.5/tut/node67.html Name Mangling in Python] 
* [http://www.tutorialspoint.com/python/python_classes_objects.htm Class Objects in Python] 
* [http://www.maths.tcd.ie/~odunlain/eiffel/eiffel_course/eforb.htm Eiffel for Beginners] 
* [http://en.wikipedia.org/wiki/Eiffel_(programming_language) More on Eiffel] 
* [http://www.maceiffel.com/Into%20Eiffel.pdf Into Eiffel By Ian Joyner] 
* [http://en.wikipedia.org/wiki/Static-typing_%28programming_languages%29#Static_and_dynamic_typing Static and Dynamic Typing]

CSC/ECE 517 Fall 2011/ch1 2b rv

2011-10-01T00:05:14Z

Abalasu3: /* C# */

CSC/ECE 517 Fall 2011/ch1 2b rv

2011-09-30T23:26:19Z

Abalasu3:

'''Access Control in O-O Languages

__TOC__

=Introduction to Access control=

In [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming], access control refers to the control of visibility of data and methods. The main idea behind access control is to restrict access to certain parts of the code to external entities. Access control implements [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation] by providing varying levels of access to code. The use of access control becomes necessary in any practical environment where selective access is a key criterion. 
For example, only the instructor can be allowed to modify grades of students but all students should be given access to retrieve and view their respective grades.
Access control in different object oriented languages and the underlying details will be covered in this topic.

=Overview of Access Control Mechanisms=

Each O-O language has a specific implementation of access control mechanisms. However, a plethora of the most widely used o-o languages share similar features while implementing access control. Access control mechanisms are applicable to class members like variables and functions. Some level of access control can be applied at the class level. The 3 basic types of access control implementation which is common to some [http://en.wikipedia.org/wiki/Static-typing_%28programming_languages%29#Static_and_dynamic_typing static and dynamic O-O languages] [like C++, C#, Java and Ruby] are 
 
'''Public''' : Methods or attributes that are declared to be public can be accessed from any class. This is the least restrictive access control method. For example, we may want everyone in a company to know the names of people working along with them. Thus give public access to the Employee's Name to everyone.

'''Private''' : This mechanism makes the data or method to be visible only in the class in which it is declared. The support is not extended to sub classes. This is the most restrictive access control method.
In any application, methods which implement the core functionality or require administrator access are declared to be private thereby enforcing limited access. For example, only a manager can be given the authority to review an employee’s performance and award bonus and promotions.

'''Protected''' : The use of protected access allows access of data and methods to be modified by members belonging to the same family. This means that this support is extended to subclasses. Protected access control can be used to support the single interface, multiple implementation concept i.e, [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inheritance].
For example, a super class may have a protected method called ComputeArea(). We can have many subclasses like Triangle, Rectangle etc inherit the super class and override the method ComputeArea() to provide their own specific implementation.

=Implementing Access Control=

Access control is implemented in different languages in their own way.We present a few of the languages that use access control and show their implementation.

=='''Java'''==
In Java, access control is achieved using the modifiers public, private and protected. If a class is not declared with any modifier, then the default access becomes package-private i.e, any object within the package should be able to access this class.

'''Public Keyword''' – Other classes can modify public fields unless its declared as final. The syntax for declaring a variable/method public is as follows 
<pre>public int x;
public void print_Hello()</pre>

In the example shown below, the variable studentName is public and hence can be accessed in another class Student2. Similarly, public methods like getName() etc become accessible by other classes. 
'''Private Keyword''' – This keyword makes the class members private. Private members can only be accessed from within the class. They are not visible even in subclasses. However, visibility and access of private members is extended to nested classes. The syntax for declaring a variable/method private is as follows
<pre>private String EmpID;
private void getEmpDetails() </pre>

In the example code below, the method setID is declared to be private. Hence, it cannot be accessed in the subclass of the class Student.

'''Protected Keyword''' – This keyword when used before a class member makes that member visible to the elements residing in that class and its subclasses. The syntax for declaring a variable/method protected is as follows
<pre>protected int sides;
protected void setArea(int sides)</pre>

In the example code below, the method setName is declared as protected. Hence, it can be accessed in the subclass NewStudent.

'''Default access level/Package''' – When no specific access control keyword is given, then the method or variable becomes accessible to all classes under a particular package. In the following example, the integer “packageVar” becomes accessible to all classes included in the package ‘TestPackage1’. Hence, it can be modified in the class Student2.

<pre>

Example:

package TestPackage1
public class Student {

public String studentName;
public int studentID;
int packageVar;

public String getName() {
return studentName;
}
public int getID() {
return studentID;
}
protected void setName(String s) {
studentName = s;
}
private void setID(int y) {
studentID = y;
}
public static void main(String[] args) {
Student Stu1 = new Student();
Stu1.setName("ABCD");
Stu1.setID(1230013);
System.out.println(Stu1.getName() + Stu1.getID());
}
}
public class NewStudent extends Student {
public static void main(String[] args) {
NewStudent NewStu1 = new NewStudent();
NewStu1.setName("EFGH"); //Can be accessed
NewStu1.setID(350); // Cannot be accessed as setID is private
System.out.println(NewStu1.getName());
}
}
public class Student2 {
public static void main(String[] args) {
Student Stu2 = new Student();
Stu2.studentName = "Mickey"; //Public variable of another class can be accessed
Stu2.packageVar = 5; //Default access level
}
}
</pre>

=='''C++==
In C++, we have the three modifiers presented in the overview along with a special type of access control called [http://en.wikipedia.org/wiki/Friend_function friend]. The behavior of public, private and protected modifiers is similar to its Java counterparts.

Friend - A function or class can access the private and protected members of a class if it is declared as a friend of that class. 

<pre>
class Number
{ int a,b;
friend int canAccess(Number numb); // Declaring canAccess() to be a friend
public:
int add(int,int);
protected:
int diff(int,int);
private:
int prod(int,int);

int add(int a,int b)
{
return a+b;
}
int diff(int a,int b)
{
if (a>b)
return a-b;
else
return b-a;
}
int prod(int a,int b)
{
return a*b;
}
};
public static void main()
{
Number num;
int a=10, b=20;
cout << "Sum =" << num.add(a,b);
cout << "Difference =" << num.diff(a,b);
//cout << "Product = " << num.prod(a,b); // this will throw an error if the comments are removed
}

// Friend function
int canAccess(Number numb)
{
cout<< "Product for a friend = " << numb.prod(10,20)
}

</pre>

'''More about friend functions'''

If a class is declared as a friend in another class, the friend class can access all the private members of the class. This can also be limited in such a way that only few private members of the class can be accessed. By using friend functions or classes, we can provide a flexibility of letting a friend class access restricted members of a class and still keeping the restricted members closed for access by any other class. This will be useful in a few cases.

=='''Ruby==
Ruby provides the three levels of access controls, private, public and protected with the default being public access. The behavior of public and protected access control is similar to other languages like C++ and Java.
However, private methods can be called only within the context of the current object. Other object’s private method cannot be invoked. Private methods can be overridden by the sub-classes.In most cases, private methods are used to provide internal functionality to the class. So we need to use a cautious approach in using private methods. If they are overridden by the subclass, we tend to get unexpected behavior in the program.

'''Note''': Private methods cannot be called outside of the class. Private methods can be called only using the “send” method. 

<pre>
class Number
def initialize(a,b)
@number1 = a
@number2 = b
end
def num1
@number1
end
def num2
@number2
end
def add(a)
puts a.num1+a.num2
end
def diff(a)
puts a.num1-a.num2
end
public:add
public:diff
protected:num1
#private:num2
end
Num1=Number.new(50,60)
Num1.add(Num1)
Num1.diff(Num1)
</pre>

This program runs successfully and prints the output as long as the private method is not accessed. Here, the private method is num2 and should not be invoked in the current context of the object.

<pre>in `add': private method `num2' called for #<Number:0x436e18 @number1=50, @number2=60> (NoMethodError)</pre>

However, the private method num2 can be accessed using the send method. The syntax for accessing the method is '''a.send(:num2)

=='''C#==
It has 5 specific levels of access control at the class member level.

'''1. Public''' : Public access is the least restrictive access level and class members can be accessed anywhere. 
'''2. Private''' : Private is the most restrictive access level where members are accessed only in the body of the class in which they are declared. This support is also extended to nested classes. 
'''3. Protected''' : The protected keyword is a member access modifier i.e, it cannot be applied at a class level. A protected member is accessible from within the class in which it is declared, and from within any class derived from the class that declared this member.

<pre>
class A
{
public int x;
protected int y = 20;
private int c;
public double AccessC() {
return c;
}
}

class B
{
public static void Main()
{
A ax = new A();
ax.x = 10; //access to public members
ax.c = 5; // can't as 'c' is declared private
int try = ax.AccessC(); // error thrown as 'c' is private
}
}

class C : A
{
public static void Main()
{
A a2 = new A();
a2.y = 10; // access to protected member
}
}
</pre>

'''4. Internal''' : It is an access modifier for types and type members. Internal members are accessible only within files in the same assembly.
'''5. Protected Internal''': This access control restricts access of members to the class, subclass within the assembly. The difference between protected internal and internal is that, a subclass of the class derived in another assembly can also access the protected internal method.

<pre>
File1.cs:
class Class1
{
internal static int Random = 0;
protected internal int Access = 0;
}
File2.cs
class Class2 : Class1
{
public static void Main()
{
Class1 c1 = new Class1();
c1.Random = 4 // error, Class1 not visible outside assembly
c1.Access = 5 // Allowed. As Access is protected internal.
}
}
</pre>

=='''Python==
Python implements access control in a different way from most other languages in that they don’t have specific access control modifiers. By default all members are public and we precede the member name with ‘__’ (a double underscore) to indicate if the member is private. This feature of python is called as [http://en.wikipedia.org/wiki/Name_mangling Name Mangling]. 

There is no feature in python to implement the protected access control. 

<pre>
class Number:
def __init(self,a,b): // this is a private method
self.a = a
self.b = b

def add():
print self.a + self.b

def diff():
print self.b - self.a

Num1=Number(50,60)
Num1.add()
Num1.diff()
</pre>

Note that in python the __init method is made to be private as default while programming. 

'''More on Name Mangling in Python
Name mangling is a feature of python using which we indicate whether a member is private by just adding underscores, instead of using key words. When we program or debug, it is easier to note that the member is private and thus refrain from accessing it.

=='''Eiffel==
Eiffel has a different approach to access control compared to the previous object oriented languages like C++ and Java. It uses ''selective export'', which means that different methods and attributes can have different access levels. Also, we can individually specify the access level for each method or attribute.

<pre>
class Number
feature{NONE} -- indicates nothing can access this code from outside of the class (private)
a: INTEGER
b: INTEGER
initialize is
do
a := 10
b := 20
end
end
feature{ANY} -- indicates this method can be accessed from anywhere outside of the class(public)
add: INTEGER is
do
Result := a+b
end
end
feature{Number} -- indicates that this method can be accessed only by members of the class Number
diff: INTEGER is
do
Result := b-a
end
end
</pre>

'''More on feature:
Using feature, we can provide varying levels of access to a code in the class. And also we can provide the names of classes that are only allowed to access that part of the code. In the above example, the different access levels that features provide are explained in the comments.

=Comparison among different O-O languages=

{|class="wikitable"
|-
!
!Java
!C++
!C#
!Ruby
!Python
!Eiffel
|-
|Public
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|-
|Protected
|Access within the class and sub-classes
|Access within the class and subclasses
|Access within the class and subclasses
|Access within the class and subclasses
|No protected access
|Access can be given to only a few of the classes.
|-
|Private
|Cannot be directly accessed from outside the class. Can be accessed by nested classes.
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|-
|Special feature
|Default access is package. Any class in a package can access if no modifier is given
|friend functions(access of private to a specific friend class or method)
|internal and protected internal
|send method is used to access private members
|Name Mangling(use of underscores to indicate access level)
|Selective export using "feature"
|}

=A short note on the usage of Access Control=

With many access control mechanisms defined, there is always the question of which access control can be used. This is decided at the discretion of the programmer but as a good programming practice, the following can be used.

1. Use public access only if an interface for a class so that the data can be sent or modified based on external requirements.
2. Use of private is advisable whenever we program the internal structure of the program, like the constructors. Some languages, like Ruby make their variables private by default so that modifications from external entities are avoided.

=Summary=

Access control provides powerful mechanism to implement encapsulation and it can find its use in several of the applications. However, if not used with caution, access control can lead to unexpected behavior in the program. It is always important to use the right access control for the situation to avoid ambiguity and ease the maintainability of code.

=References=

* [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] 
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation] 
* [http://download.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html Access Control in Java] 
* [http://msdn.microsoft.com/en-us/library/kktasw36(v=VS.80).aspx Member Access Control in C++] 
* [http://www.exforsys.com/tutorials/c-plus-plus/c-plus-plus-friend-functions.html C++ friend functions] 
* [http://en.wikipedia.org/wiki/Friend_function Implementing friend functions] 
* [http://msdn.microsoft.com/en-us/library/ms173121.aspx Access Modifiers in C#] 
* [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_classes.html Programming Ruby] 
* [http://rubylearning.com/satishtalim/ruby_access_control.html Access Control in Ruby] 
* [http://en.wikipedia.org/wiki/Name_mangling Name Mangling in OO Langugages] 
* [http://docs.python.org/release/1.5/tut/node67.html Name Mangling in Python] 
* [http://www.tutorialspoint.com/python/python_classes_objects.htm Class Objects in Python] 
* [http://www.maths.tcd.ie/~odunlain/eiffel/eiffel_course/eforb.htm Eiffel for Beginners] 
* [http://en.wikipedia.org/wiki/Eiffel_(programming_language) More on Eiffel] 
* [http://www.maceiffel.com/Into%20Eiffel.pdf Into Eiffel By Ian Joyner] 
* [http://en.wikipedia.org/wiki/Static-typing_%28programming_languages%29#Static_and_dynamic_typing Static and Dynamic Typing]

CSC/ECE 517 Fall 2011/ch1 2b rv

2011-09-22T19:22:20Z

Abalasu3: /* Comparison among different O-O languages */

__TOC__

=Introduction to Access control=

In [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming], access control refers to the control of visibility of data and methods. The main idea behind access control is to hide the underlying implementation of functions behind its public interface. Access control implements [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation] by providing varying levels of access to code. The use of access control becomes necessary in any practical environment where selective access is a key criterion. 
For example, only the instructor can be allowed to modify grades of students but all students should be given access to retrieve and view their respective grades.
Access control in different object oriented languages and the underlying details will be covered in this topic.

=Overview of Access Control Mechanisms=
Each O-O language has a specific implementation of access control mechanisms. However, a plethora of the most widely used o-o languages share similar features while implementing access control. Access control mechanisms are applicable to class members like variables and functions. Some level of access control can be applied at the class level. The 3 basic types of access control implementation which is common to some static and dynamic O-O languages [like C++, C#, Java and Ruby] are 
 
'''Public''' : Methods or attributes that are declared to be public can be accessed from any class. This is the least restrictive access control method.

'''Private''' : This mechanism makes the data or method to be visible only in the class in which it is declared. The support is not extended to sub classes. This is the most restrictive access control method.
In any application, methods which implement the core functionality or require administrator access are declared to be private thereby enforcing limited access. For example, only a manager can be given the authority to review an employee’s performance and award bonus and promotions.

'''Protected''' : The use of protected access allows access of data and methods to be modified by members belonging to the same family. This means that this support is extended to subclasses. Protected access control can be used to support the single interface, multiple implementation concept i.e, [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inheritance].
For example, a super class may have a protected method called ComputeArea(). We can have many subclasses like Triangle, Rectangle etc inherit the super class and override the method ComputeArea() to provide their own specific implementation.

=Implementing Access Control=

Access control is implemented in different languages in their own way.We present a few of the languages that use access control and show their implementation.

=='''Java'''==
In Java, access control is achieved using the modifiers public, private and protected. If a class is not declared with any modifier, then the default access becomes package-private i.e, any object within the package should be able to access this class.

'''Public Keyword''' – Other classes can modify public fields unless its declared as final. The syntax for declaring a variable/method public is as follows 
<pre>public int x;
public void print_Hello()</pre>

In the example shown below, the variable studentName is public and hence can be accessed in another class Student2. Similarly, public methods like getName() etc become accessible by other classes. 
'''Private Keyword''' – This keyword makes the class members private. Private members can only be accessed from within the class. They are not visible even in subclasses. However, visibility and access of private members is extended to nested classes. The syntax for declaring a variable/method private is as follows
<pre>private String EmpID;
private void getEmpDetails() </pre>

In the example code below, the method setID is declared to be private. Hence, it cannot be accessed in the subclass of the class Student.

'''Protected Keyword''' – This keyword when used before a class member makes that member visible to the elements residing in that class and its subclasses. The syntax for declaring a variable/method protected is as follows
<pre>protected int sides;
protected void setArea(int sides)</pre>

In the example code below, the method setName is declared as protected. Hence, it can be accessed in the subclass NewStudent.

'''Default access level/Package''' – When no specific access control keyword is given, then the method or variable becomes accessible to all classes under a particular package. In the following example, the integer “packageVar” becomes accessible to all classes included in the package ‘TestPackage1’. Hence, it can be modified in the class Student2.

<pre>

Example:

package TestPackage1
public class Student {

public String studentName;
public int studentID;
int packageVar;

public String getName() {
return studentName;
}
public int getID() {
return studentID;
}
protected void setName(String s) {
studentName = s;
}
private void setID(int y) {
studentID = y;
}
public static void main(String[] args) {
Student Stu1 = new Student();
Stu1.setName("ABCD");
Stu1.setID(1230013);
System.out.println(Stu1.getName() + Stu1.getID());
}
}
public class NewStudent extends Student {
public static void main(String[] args) {
NewStudent NewStu1 = new NewStudent();
NewStu1.setName("EFGH"); //Can be accessed
NewStu1.setID(350); // Cannot be accessed as setID is private
System.out.println(NewStu1.getName());
}
}
public class Student2 {
public static void main(String[] args) {
Student Stu2 = new Student();
Stu2.studentName = "Mickey"; //Public variable of another class can be accessed
Stu2.packageVar = 5; //Default access level
}
}
</pre>

=='''C++==

In C++, we have the three modifiers presented in the overview along with a special type of access control called [http://en.wikipedia.org/wiki/Friend_function friend]. The behavior of public, private and protected modifiers is similar to its Java counterparts.

Friend - A function or class can access the private and protected members of a class if it is declared as a friend of that class. 

<pre>
class Number
{ int a,b;
friend int canAccess(Number numb); // Declaring canAccess() to be a friend
public:
int add(int,int);
protected:
int diff(int,int);
private:
int prod(int,int);

int add(int a,int b)
{
return a+b;
}
int diff(int a,int b)
{
if (a>b)
return a-b;
else
return b-a;
}
int prod(int a,int b)
{
return a*b;
}
};
public static void main()
{
Number num;
int a=10, b=20;
cout << "Sum =" << num.add(a,b);
cout << "Difference =" << num.diff(a,b);
//cout << "Product = " << num.prod(a,b); // this will throw an error if the comments are removed
}

// Friend function
int canAccess(Number numb)
{
cout<< "Product for a friend = " << numb.prod(10,20)
}

</pre>

'''More about friend functions'''

If a class is declared as a friend in another class, the friend class can access all the private members of the class. This can also be limited in such a way that only few private members of the class can be accessed. By using friend functions or classes, we can provide a flexibility of letting a friend class access restricted members of a class and still keeping the restricted members closed for access by any other class. This will be useful in a few cases.

=='''Ruby==

Ruby provides the three levels of access controls, private, public and protected with the default being public access. The behavior of public and protected access control is similar to other languages like C++ and Java.
However, private methods can be called only within the context of the current object. Other object’s private method cannot be invoked. Private methods can be overridden by the sub-classes.In most cases, private methods are used to provide internal functionality to the class. So we need to use a cautious approach in using private methods. If they are overridden by the subclass, we tend to get unexpected behavior in the program.

'''Note''': Private methods cannot be called outside of the class. Private methods can be called only using the “send” method. 

<pre>
class Number
def initialize(a,b)
@number1 = a
@number2 = b
end
def num1
@number1
end
def num2
@number2
end
def add(a)
puts a.num1+a.num2
end
def diff(a)
puts a.num1-a.num2
end
public:add
public:diff
protected:num1
#private:num2
end
Num1=Number.new(50,60)
Num1.add(Num1)
Num1.diff(Num1)
</pre>

This program runs successfully and prints the output as long as the private method is not accessed. Here, the private method is num2 and should not be invoked in the current context of the object.

<pre>in `add': private method `num2' called for #<Number:0x436e18 @number1=50, @number2=60> (NoMethodError)</pre>

However, the private method num2 can be accessed using the send method. The syntax for accessing the method is '''a.send(:num2)
=='''C#==

It has 5 specific levels of access control at the class member level.

'''1. Public''' : Public access is the least restrictive access level and class members can be accessed anywhere. 
'''2. Private''' : Private is the most restrictive access level where members are accessed only in the body of the class in which they are declared. This support is also extended to nested classes. 
'''3. Protected''' : The protected keyword is a member access modifier i.e, it cannot be applied at a class level. A protected member is accessible from within the class in which it is declared, and from within any class derived from the class that declared this member.

<pre>
class A
{
public int x;
protected int y = 20;
private int c;
public double AccessC() {
return c;
}
}

class B
{
public static void Main()
{
A ax = new A();
ax.x = 10; //access to public members
ax.c = 5; // can't as 'c' is declared private
int try = ax.AccessC(); // error thrown as 'c' is private
}
}

class C : A
{
public static void Main()
{
A a2 = new A();
a2.y = 10; // access to protected member
}
}
</pre>

'''4. Internal''' : It is an access modifier for types and type members. Internal members are accessible only within files in the same assembly.
'''5. Protected Internal''': This access control restricts access of members to the class, subclass within the assembly. The difference between protected internal and internal is that, a subclass of the class derived in another assembly can also access the protected internal method.

<pre>
File1.cs:
class Class1
{
internal static int Random = 0;
protected internal int Access = 0;
}
File2.cs
class Class2 : Class1
{
public static void Main()
{
Class1 c1 = new Class1();
c1.Random = 4 // error, Class1 not visible outside assembly
c1.Access = 5 // Allowed. As Access is protected internal.
}
}
</pre>

=='''Python==

Python implements access control in a different way from most other languages in that they don’t have specific access control modifiers. By default all members are public and we precede the member name with ‘__’ (a double underscore) to indicate if the member is private. This feature of python is called as [http://en.wikipedia.org/wiki/Name_mangling Name Mangling]. 

There is no feature in python to implement the protected access control. 

<pre>
class Number:
def __init(self,a,b): // this is a private method
self.a = a
self.b = b

def add():
print self.a + self.b

def diff():
print self.b - self.a

Num1=Number(50,60)
Num1.add()
Num1.diff()
</pre>

Note that in python the __init method is made to be private as default while programming. 

'''More on Name Mangling in Python
Name mangling is a feature of python using which we indicate whether a member is private by just adding underscores, instead of using key words. When we program or debug, it is easier to note that the member is private and thus refrain from accessing it.

=='''Eiffel==

Eiffel has a different approach to access control compared to the previous object oriented languages like C++ and Java. It uses ''selective export'', which means that different methods and attributes can have different access levels. Also, we can individually specify the access level for each method or attribute.

<pre>
class Number
feature{NONE} -- indicates nothing can access this code from outside of the class (private)
a: INTEGER
b: INTEGER
initialize is
do
a := 10
b := 20
end
end
feature{ANY} -- indicates this method can be accessed from anywhere outside of the class(public)
add: INTEGER is
do
Result := a+b
end
end
feature{Number} -- indicates that this method can be accessed only by members of the class Number
diff: INTEGER is
do
Result := b-a
end
end
</pre>

'''More on feature:
Using feature, we can provide varying levels of access to a code in the class. And also we can provide the names of classes that are only allowed to access that part of the code. In the above example, the different access levels that features provide are explained in the comments.

=Comparison among different O-O languages=

{|class="wikitable"
|-
!
!Java
!C++
!C#
!Ruby
!Python
!Eiffel
|-
|Public
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|Can be accessed outside of class
|-
|Protected
|Access within the class and sub-classes
|Access within the class and subclasses
|Access within the class and subclasses
|Access within the class and subclasses
|No protected access
|Access can be given to only a few of the classes.
|-
|Private
|Cannot be directly accessed from outside the class. Can be accessed by nested classes.
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|Cannot be directly accessed from outside the class
|-
|Special feature
|Default access is package. Any class in a package can access if no modifier is given
|friend functions(access of private to a specific friend class or method)
|internal and protected internal
|send method is used to access private members
|Name Mangling(use of underscores to indicate access level)
|Selective export using "feature"
|}

=A short note on the usage of Access Control=

With many access control mechanisms defined, there is always the question of which access control can be used. This is decided at the discretion of the programmer but as a good programming practice, the following can be used.

1. Use public access only if an interface for a class so that the data can be sent or modified based on external requirements.
2. Use of private is advisable whenever we program the internal structure of the program, like the constructors. Some languages, like Ruby make their variables private by default so that modifications from external entities are avoided.

=Summary=
Access control provides powerful mechanism to implement encapsulation and it can find its use in several of the applications. However, if not used with caution, access control can lead to unexpected behavior in the program. It is always important to use the right access control for the situation to avoid ambiguity and ease the maintainability of code.

=References=

* [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming] 
* [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation] 
* [http://download.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html Access Control in Java] 
* [http://msdn.microsoft.com/en-us/library/kktasw36(v=VS.80).aspx Member Access Control in C++] 
* [http://www.exforsys.com/tutorials/c-plus-plus/c-plus-plus-friend-functions.html C++ friend functions] 
* [http://en.wikipedia.org/wiki/Friend_function Implementing friend functions] 
* [http://msdn.microsoft.com/en-us/library/ms173121.aspx Access Modifiers in C#] 
* [http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_classes.html Programming Ruby] 
* [http://rubylearning.com/satishtalim/ruby_access_control.html Access Control in Ruby] 
* [http://en.wikipedia.org/wiki/Name_mangling Name Mangling in OO Langugages] 
* [http://docs.python.org/release/1.5/tut/node67.html Name Mangling in Python] 
* [http://www.tutorialspoint.com/python/python_classes_objects.htm Class Objects in Python] 
* [http://www.maths.tcd.ie/~odunlain/eiffel/eiffel_course/eforb.htm Eiffel for Beginners] 
* [http://en.wikipedia.org/wiki/Eiffel_(programming_language) More on Eiffel] 
* [http://www.maceiffel.com/Into%20Eiffel.pdf Into Eiffel By Ian Joyner]