Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-30T01:54:12Z

Sramach5: /* Additional Reading */

==Introduction==
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection ]is a relatively common [http://en.wikipedia.org/wiki/Computer_programming computer programming] concept where in the program has the inherent ability to examine itself at run time. Based on its observations the program can modify it's behavior for the given situation.The modifications can be any aspect of the programming language .i.e syntax, semantics, or implementation.

Reflection as a concept was first introduced in the doctoral dissertation of Dr. Brian Cantwell Smith<ref>[http://hdl.handle.net/1721.1/15961 Brian Cantwell Smith, Procedural Reflection in Programming Languages, Department of Electrical Engineering and Computer Science, Massachusetts Institute of Technology, PhD Thesis, 1982.]</ref><ref>[http://publications.csail.mit.edu/lcs/specpub.php?id=840 Brian C. Smith. Reflection and semantics in a procedural language. Technical Report MIT-LCS-TR-272, Massachusetts Institute of Technology, Cambridge, Mass., January 1982.]</ref> in 1992.

==Reflection==
Reflection is the ability of a program or a computation to examine and modify itself at run time even though it does not have enough information at compile time. For example in a high level object oriented language the ability to inspect its class , interfaces and methods at run time without knowing their names at compile time. It provides the ability to modify , instantiate and access to methods such as getter's and setter's of a class. Since the program need not have all the information at compile time it makes the program more dynamic.

In the simple illustration provided below in ruby we can see how the name of a class can be obtained from the object and how we can get the ancestor classes and modules of a particular class.
<pre>

5.class #=> Fixnum

"hello".class #=> String

String.ancestors #=> [String, Enumerable, Comparable, Object, Kernel]

</pre>
Some of the common information that can be obtained from reflection are :
* Object type
* [http://en.wikipedia.org/wiki/Superclass_%28computer_science%29#Subclasses_and_superclasses Super classes] of any class
* [http://en.wikipedia.org/wiki/Method_(computer_programming) Methods]
* class fields
* [http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces]

Common languages that exhibit reflection to varying degrees are Ruby, Java, Smalltalk, C# and more.

== Types of reflection ==
There are two basic types of reflection. They are:
* Behavioral Reflection: This type of reflection changes the behaviour of the execution of the program based on observation and modification.
* Structural Reflection: This type of reflection deals with changing the very structure of the program such as the data structures and flow of control in the program.

==Implementation==
There are many challenges faced by designers of reflective languages. They must provide as much leeway as possible for late binging and at the same time they must optimize the compilation of the static components so that they are ready for run-time. Reflection is in essense a connection between the object-level (program) and meta-level (the processor). The ability of the object level to be able to observe and modify the meta-level information is the consequence of this connection. These actions can be termed as [http://en.wikipedia.org/wiki/Type_introspection introspection] (This involves the action of observing the class) and intercession (this involves the operation of modifying the behavior of the class). These actions can implemented with the implementation of the following components:

* Ability to create [http://en.wikipedia.org/wiki/First-class_object first class objects] ie [http://en.wikipedia.org/wiki/Reification_(computer_science) reification].

* Ability to convert a string that denotes a class or a method into its corresponding reference or invocation.

* Ability to use and create symbolic links to methods and classes.

==Reflection by example==
===C#===
<pre>
int val = 20;
System.Type type = val.GetType();
System.Console.WriteLine(type);
</pre>
Output is type of the variable "val" = System.Int32

===Smalltalk===
<pre>
w := Workspace new.
w openLabel:'My Workspace'
w inspect
</pre>
Here we can inspect all the methods available to the instance 'w'.

===Java===
<pre>
import java.lang.reflect.*;
public class Fclass{
public static void main(String[] args){
Class cls = java.lang.Integer.class;
String info;
info = cls.getName(); // It will show java.lang.Integer
System.out.println(info);
}
}
</pre>
cls.getName() gives the complete class name which is printed out as the output of the above code is "java.lang.Integer"

===PHP===
<pre>
$reflector = new ReflectionClass("SimpleXMLElement");
echo $reflector;
</pre>
Output of this example is the complete class map of the class SimpleXMLElement.

==Dynamic binding : Making reflection possible==

Ruby implements [http://en.wikipedia.org/wiki/Dynamic_dispatch dynamic binding] of objects. Dynamic binding plays a very important role in [http://en.wikipedia.org/wiki/Metaprogramming meta-programming].

In languages like C,C++; a simple assignment "a = b", would require 'a' and 'b' to be of the same type. The assignment is interpreted as copying b into a and is implemented by copying the contents of b into the space occupied by a. Thus if 'a' had been declared as an object whose memory size is less than b's object, then object slicing takes place i.e. only that part of 'b' which fits into a's memory would be copied. This behavior might lead to unintended consequences.

[[File:Slicing.gif]]

But dynamic binding in Ruby ensures that the type of object stored in a variable is determined at run time and not at compile time. Thus the assignment "a = b" is interpreted as binding 'a' to the same object that 'b' is bound to. It is implemented by copying the reference stored in b into the (pointer-sized) memory cell of 'a'. Thus 'a' and 'b' point to the same object after the assignment.

[[File:Before_binding.png]] [[File:After_binding.png]]

==Symbols and their usage in reflection techniques==

===Basics===
[http://en.wikipedia.org/wiki/Symbol_%28programming%29 Symbols] are objects used to represent names and strings inside a Ruby [http://en.wikipedia.org/wiki/Interpreter_%28computing%29 interpreter]. They are immutable and remain unique i.e. every instance of a particular symbol is the same symbol.

===Usage in reflection techniques===
Symbols are widely used in reflection to invoke methods dynamically. Reflection methods like 'respond_to', 'send' make use of symbols as a reference to other methods. Strings can also be used in place of symbols. However symbols are more efficient compared to strings in terms of memory and performance.

===Examples===

====Passing method by reference using a symbol====
<pre>
class Float
def poly
self*self*self + 2*self*self + 3*self + 4
end
end
</pre>
And we can pass poly to an integration routine:
<pre>
area = integrate(:poly, 0, 10)
</pre>

====Symbols in reflection====
[http://ruby-doc.org/core-1.9.2/Object.html#method-i-send Send] method

<pre>
irb(main):015:0> to = [:to_s , :to_f]
=> [:to_s, :to_f]
irb(main):016:0> to.each{|method| puts "#{method} => #{5.send method}"}
to_s => 5
to_f => 5.0
=> [:to_s, :to_f]
</pre>

[http://ruby-doc.org/core-1.9.2/Object.html#method-i-respond_to-3F respond_to] method

<pre>
5.respond_to? :slice #=> false
5.respond_to? :to_f #=> true
</pre>
<pre>
obj = Object.new
if obj.respond_to?(:program)
obj.program
else
puts "Sorry, the object doesn't understand the 'program' message."
end
</pre>

==method_missing==

Whenever a call to a method is made on an object , Ruby does a method look up. If the method is not found, Ruby calls a method named '[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]'. Ruby knows the existence of the 'method_missing' as all objects are instances of 'BasicObject' which includes 'method_missing'. The default behavior of BasicObject#method_missing is to respond by raising a [http://www.ruby-doc.org/core-1.9.2/NoMethodError.html NoMethodError].

[http://en.wikipedia.org/wiki/Method_overriding Overriding] 'method_missing' allows users to call methods that don't really exist. The example below illustrates overriding of 'method_missing' to the programmer's advantage. Ruby passes as parameters the name of the method called and the arguments passed to it.

'''Example1'''
<pre>
class Cat
def mew
puts "Meow"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
c = Cat.new
c.mew
>>Meow
c.bark
>> Sorry, I do not bark
</pre>

In the above example, as the method 'bark' does not exist, method_missing is called with the meth (method name as a symbol) :bark. Hence the result " Sorry, I do not bark "

'''Example2'''
Using method_missing to convert Roman numerals <ref>http://www.rubyquiz.com/quiz22.html</ref> to integers

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end
</pre>

Evaluating Roman.xix calls the xix method of module Roman. Roman has no xix method, so method_missing is invoked with :xix as the argument.The id2name method of class Symbol is invoked on xix returning "xix". The "xix" is then parsed according to the rules for evaluating Roman numerals, and evaluates to 19.

''' Example 3 '''
<pre>
class Performer
def method_missing(name, *args)
"The duck will #{name}: #{args[0]}"
end
end

duck = Performer.new
duck.sing("Quacking in the Rain") # => "The duck will sing: Quacking in the Rain"
duck.dance("Swan Lake") # => "The duck will dance: Swan Lake"
</pre>

==Applications of Reflection==
*Reflection has become invaluable to programmers who need to connect code with data. For example in a GUI environment a button might need to invoke different methods in different classes. Reflection can be used here to call the method on any given class.

*Programmers who deal with a multitude of classes at the same time can use reflection to create a “serializer” that for a given class uses reflection to go through all the instance variables and processes them accordingly.

*Reflection is used in large test frameworks where reflection helps in identifying the test methods for different scenarios.

*Reflection provides the ability to morph the code based on dynamic situations. This provides a sense of artificial intelligence to the program as whole.

*Reflection can be used to debug and verify code as it provides access to the insides of a program.

*Reflection is very useful when the software is upgraded regularly. It provides an easy method to check for available methods and classes. This prevents the errors caused by the absense of methods and classes when they are deprecated.

==Advantages and disadvantages of reflection==

===Advantages===
* Extensibility: Reflection provides the capability of using external and user defined classes by instantiation of extensibility objects using their fully qualified names.
* Class browsers in IDEs: The ability to examine the members of classes makes implementation of visual aids , auto-completion and documentation easy in development tools for programmers.
* Debugging: Reflection allows the user to observe the private members in classes. This capability can be used to debug classes and their interactions.
* Test Harness : Reflection can be used to call a set of testing APIs defined on a class for maximum coverage of testing.
* Correctness : Reflection improves the robustness and the correctness of a program especially in dynamically typed languages as runtime checks can be added to check the availability of the methods or classes.

===Disadvantages===
* Reflection introduces lot of performance overhead when compared to non-reflective code. Hence it should be used judiciously.
* Since it provides access to the internals of a class or an encapsulated object security becomes a major issue.
* Since it is run-time binding we lose the security of compile time checks and verification.

==Conclusion==
This article makes an attempt to explain the concept of Reflection in Object Oriented Programming. The article mentions the different approaches to reflection in Ruby and other languages.It mentions the usage of Reflections and the advantages and disadvantages of using Reflection. A follow up to this article would be to study the concept of [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==References==
<references/>

==Additional Reading==
*[http://en.wikipedia.org/wiki/Reflection_(computer_programming) Reflection]
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]
*[http://tutorials.jenkov.com/java-reflection/classes.html Java Reflection]
*[http://www.slideshare.net/CiaranMcHale/java-reflection-explained-simply Java reflection basics]
*[http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/malenfant/ref96/ref96.html A Tutorial on Behavioral Reflection and its Implementation]
*[http://www.quora.com/Computer-Programming/How-is-reflection-useful Uses of reflection]
*[http://download.oracle.com/javase/tutorial/reflect/index.html Java reflection official website]
*[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Ruby Documentation]
*[http://www.slideshare.net/MarcusDenker/behavioral-reflection Behavioral reflection]

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-30T01:53:40Z

Sramach5: /* Types of reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-30T01:51:07Z

Sramach5: /* Types of reflection */

==Introduction==
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection ]is a relatively common [http://en.wikipedia.org/wiki/Computer_programming computer programming] concept where in the program has the inherent ability to examine itself at run time. Based on its observations the program can modify it's behavior for the given situation.The modifications can be any aspect of the programming language .i.e syntax, semantics, or implementation.

Reflection as a concept was first introduced in the doctoral dissertation of Dr. Brian Cantwell Smith<ref>[http://hdl.handle.net/1721.1/15961 Brian Cantwell Smith, Procedural Reflection in Programming Languages, Department of Electrical Engineering and Computer Science, Massachusetts Institute of Technology, PhD Thesis, 1982.]</ref><ref>[http://publications.csail.mit.edu/lcs/specpub.php?id=840 Brian C. Smith. Reflection and semantics in a procedural language. Technical Report MIT-LCS-TR-272, Massachusetts Institute of Technology, Cambridge, Mass., January 1982.]</ref> in 1992.

==Reflection==
Reflection is the ability of a program or a computation to examine and modify itself at run time even though it does not have enough information at compile time. For example in a high level object oriented language the ability to inspect its class , interfaces and methods at run time without knowing their names at compile time. It provides the ability to modify , instantiate and access to methods such as getter's and setter's of a class. Since the program need not have all the information at compile time it makes the program more dynamic.

In the simple illustration provided below in ruby we can see how the name of a class can be obtained from the object and how we can get the ancestor classes and modules of a particular class.
<pre>

5.class #=> Fixnum

"hello".class #=> String

String.ancestors #=> [String, Enumerable, Comparable, Object, Kernel]

</pre>
Some of the common information that can be obtained from reflection are :
* Object type
* [http://en.wikipedia.org/wiki/Superclass_%28computer_science%29#Subclasses_and_superclasses Super classes] of any class
* [http://en.wikipedia.org/wiki/Method_(computer_programming) Methods]
* class fields
* [http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces]

Common languages that exhibit reflection to varying degrees are Ruby, Java, Smalltalk, C# and more.

== Types of reflection ==
There are two basic types of reflection. They are:
* [http://www.slideshare.net/MarcusDenker/behavioral-reflection Behavioral Reflection]: This type of reflection changes the behaviour of the execution of the program based on observation and modification.
* Structural Reflection: This type of reflection deals with changing the very structure of the program such as the data structures and flow of control in the program.

==Implementation==
There are many challenges faced by designers of reflective languages. They must provide as much leeway as possible for late binging and at the same time they must optimize the compilation of the static components so that they are ready for run-time. Reflection is in essense a connection between the object-level (program) and meta-level (the processor). The ability of the object level to be able to observe and modify the meta-level information is the consequence of this connection. These actions can be termed as [http://en.wikipedia.org/wiki/Type_introspection introspection] (This involves the action of observing the class) and intercession (this involves the operation of modifying the behavior of the class). These actions can implemented with the implementation of the following components:

* Ability to create [http://en.wikipedia.org/wiki/First-class_object first class objects] ie [http://en.wikipedia.org/wiki/Reification_(computer_science) reification].

* Ability to convert a string that denotes a class or a method into its corresponding reference or invocation.

* Ability to use and create symbolic links to methods and classes.

==Reflection by example==
===C#===
<pre>
int val = 20;
System.Type type = val.GetType();
System.Console.WriteLine(type);
</pre>
Output is type of the variable "val" = System.Int32

===Smalltalk===
<pre>
w := Workspace new.
w openLabel:'My Workspace'
w inspect
</pre>
Here we can inspect all the methods available to the instance 'w'.

===Java===
<pre>
import java.lang.reflect.*;
public class Fclass{
public static void main(String[] args){
Class cls = java.lang.Integer.class;
String info;
info = cls.getName(); // It will show java.lang.Integer
System.out.println(info);
}
}
</pre>
cls.getName() gives the complete class name which is printed out as the output of the above code is "java.lang.Integer"

===PHP===
<pre>
$reflector = new ReflectionClass("SimpleXMLElement");
echo $reflector;
</pre>
Output of this example is the complete class map of the class SimpleXMLElement.

==Dynamic binding : Making reflection possible==

Ruby implements [http://en.wikipedia.org/wiki/Dynamic_dispatch dynamic binding] of objects. Dynamic binding plays a very important role in [http://en.wikipedia.org/wiki/Metaprogramming meta-programming].

In languages like C,C++; a simple assignment "a = b", would require 'a' and 'b' to be of the same type. The assignment is interpreted as copying b into a and is implemented by copying the contents of b into the space occupied by a. Thus if 'a' had been declared as an object whose memory size is less than b's object, then object slicing takes place i.e. only that part of 'b' which fits into a's memory would be copied. This behavior might lead to unintended consequences.

[[File:Slicing.gif]]

But dynamic binding in Ruby ensures that the type of object stored in a variable is determined at run time and not at compile time. Thus the assignment "a = b" is interpreted as binding 'a' to the same object that 'b' is bound to. It is implemented by copying the reference stored in b into the (pointer-sized) memory cell of 'a'. Thus 'a' and 'b' point to the same object after the assignment.

[[File:Before_binding.png]] [[File:After_binding.png]]

==Symbols and their usage in reflection techniques==

===Basics===
[http://en.wikipedia.org/wiki/Symbol_%28programming%29 Symbols] are objects used to represent names and strings inside a Ruby [http://en.wikipedia.org/wiki/Interpreter_%28computing%29 interpreter]. They are immutable and remain unique i.e. every instance of a particular symbol is the same symbol.

===Usage in reflection techniques===
Symbols are widely used in reflection to invoke methods dynamically. Reflection methods like 'respond_to', 'send' make use of symbols as a reference to other methods. Strings can also be used in place of symbols. However symbols are more efficient compared to strings in terms of memory and performance.

===Examples===

====Passing method by reference using a symbol====
<pre>
class Float
def poly
self*self*self + 2*self*self + 3*self + 4
end
end
</pre>
And we can pass poly to an integration routine:
<pre>
area = integrate(:poly, 0, 10)
</pre>

====Symbols in reflection====
[http://ruby-doc.org/core-1.9.2/Object.html#method-i-send Send] method

<pre>
irb(main):015:0> to = [:to_s , :to_f]
=> [:to_s, :to_f]
irb(main):016:0> to.each{|method| puts "#{method} => #{5.send method}"}
to_s => 5
to_f => 5.0
=> [:to_s, :to_f]
</pre>

[http://ruby-doc.org/core-1.9.2/Object.html#method-i-respond_to-3F respond_to] method

<pre>
5.respond_to? :slice #=> false
5.respond_to? :to_f #=> true
</pre>
<pre>
obj = Object.new
if obj.respond_to?(:program)
obj.program
else
puts "Sorry, the object doesn't understand the 'program' message."
end
</pre>

==method_missing==

Whenever a call to a method is made on an object , Ruby does a method look up. If the method is not found, Ruby calls a method named '[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]'. Ruby knows the existence of the 'method_missing' as all objects are instances of 'BasicObject' which includes 'method_missing'. The default behavior of BasicObject#method_missing is to respond by raising a [http://www.ruby-doc.org/core-1.9.2/NoMethodError.html NoMethodError].

[http://en.wikipedia.org/wiki/Method_overriding Overriding] 'method_missing' allows users to call methods that don't really exist. The example below illustrates overriding of 'method_missing' to the programmer's advantage. Ruby passes as parameters the name of the method called and the arguments passed to it.

'''Example1'''
<pre>
class Cat
def mew
puts "Meow"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
c = Cat.new
c.mew
>>Meow
c.bark
>> Sorry, I do not bark
</pre>

In the above example, as the method 'bark' does not exist, method_missing is called with the meth (method name as a symbol) :bark. Hence the result " Sorry, I do not bark "

'''Example2'''
Using method_missing to convert Roman numerals <ref>http://www.rubyquiz.com/quiz22.html</ref> to integers

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end
</pre>

Evaluating Roman.xix calls the xix method of module Roman. Roman has no xix method, so method_missing is invoked with :xix as the argument.The id2name method of class Symbol is invoked on xix returning "xix". The "xix" is then parsed according to the rules for evaluating Roman numerals, and evaluates to 19.

''' Example 3 '''
<pre>
class Performer
def method_missing(name, *args)
"The duck will #{name}: #{args[0]}"
end
end

duck = Performer.new
duck.sing("Quacking in the Rain") # => "The duck will sing: Quacking in the Rain"
duck.dance("Swan Lake") # => "The duck will dance: Swan Lake"
</pre>

==Applications of Reflection==
*Reflection has become invaluable to programmers who need to connect code with data. For example in a GUI environment a button might need to invoke different methods in different classes. Reflection can be used here to call the method on any given class.

*Programmers who deal with a multitude of classes at the same time can use reflection to create a “serializer” that for a given class uses reflection to go through all the instance variables and processes them accordingly.

*Reflection is used in large test frameworks where reflection helps in identifying the test methods for different scenarios.

*Reflection provides the ability to morph the code based on dynamic situations. This provides a sense of artificial intelligence to the program as whole.

*Reflection can be used to debug and verify code as it provides access to the insides of a program.

*Reflection is very useful when the software is upgraded regularly. It provides an easy method to check for available methods and classes. This prevents the errors caused by the absense of methods and classes when they are deprecated.

==Advantages and disadvantages of reflection==

===Advantages===
* Extensibility: Reflection provides the capability of using external and user defined classes by instantiation of extensibility objects using their fully qualified names.
* Class browsers in IDEs: The ability to examine the members of classes makes implementation of visual aids , auto-completion and documentation easy in development tools for programmers.
* Debugging: Reflection allows the user to observe the private members in classes. This capability can be used to debug classes and their interactions.
* Test Harness : Reflection can be used to call a set of testing APIs defined on a class for maximum coverage of testing.
* Correctness : Reflection improves the robustness and the correctness of a program especially in dynamically typed languages as runtime checks can be added to check the availability of the methods or classes.

===Disadvantages===
* Reflection introduces lot of performance overhead when compared to non-reflective code. Hence it should be used judiciously.
* Since it provides access to the internals of a class or an encapsulated object security becomes a major issue.
* Since it is run-time binding we lose the security of compile time checks and verification.

==Conclusion==
This article makes an attempt to explain the concept of Reflection in Object Oriented Programming. The article mentions the different approaches to reflection in Ruby and other languages.It mentions the usage of Reflections and the advantages and disadvantages of using Reflection. A follow up to this article would be to study the concept of [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==References==
<references/>

==Additional Reading==
*[http://en.wikipedia.org/wiki/Reflection_(computer_programming) Reflection]
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]
*[http://tutorials.jenkov.com/java-reflection/classes.html Java Reflection]
*[http://www.slideshare.net/CiaranMcHale/java-reflection-explained-simply Java reflection basics]
*[http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/malenfant/ref96/ref96.html A Tutorial on Behavioral Reflection and its Implementation]
*[http://www.quora.com/Computer-Programming/How-is-reflection-useful Uses of reflection]
*[http://download.oracle.com/javase/tutorial/reflect/index.html Java reflection official website]
*[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Ruby Documentation]

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-30T01:47:29Z

Sramach5: /* Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-30T01:44:22Z

Sramach5: /* Implementation */

==Introduction==
[http://en.wikipedia.org/wiki/Reflection_%28computer_programming%29 Reflection ]is a relatively common [http://en.wikipedia.org/wiki/Computer_programming computer programming] concept where in the program has the inherent ability to examine itself at run time. Based on its observations the program can modify it's behavior for the given situation.The modifications can be any aspect of the programming language .i.e syntax, semantics, or implementation.

Reflection as a concept was first introduced in the doctoral dissertation of Dr. Brian Cantwell Smith<ref>[http://hdl.handle.net/1721.1/15961 Brian Cantwell Smith, Procedural Reflection in Programming Languages, Department of Electrical Engineering and Computer Science, Massachusetts Institute of Technology, PhD Thesis, 1982.]</ref><ref>[http://publications.csail.mit.edu/lcs/specpub.php?id=840 Brian C. Smith. Reflection and semantics in a procedural language. Technical Report MIT-LCS-TR-272, Massachusetts Institute of Technology, Cambridge, Mass., January 1982.]</ref> in 1992.

==Reflection==
Reflection is the ability of a program or a computation to examine and modify itself at run time even though it does not have enough information at compile time. For example in a high level object oriented language the ability to inspect its class , interfaces and methods at run time without knowing their names at compile time. It provides the ability to modify , instantiate and access to methods such as getter's and setter's of a class. Since the program need not have all the information at compile time it makes the program more dynamic.

In the simple illustration provided below in ruby we can see how the name of a class can be obtained from the object and how we can get the ancestor classes and modules of a particular class.
<pre>

5.class #=> Fixnum

"hello".class #=> String

String.ancestors #=> [String, Enumerable, Comparable, Object, Kernel]

</pre>
Some of the common information that can be obtained from reflection are :
* Object type
* [http://en.wikipedia.org/wiki/Superclass_%28computer_science%29#Subclasses_and_superclasses Super classes] of any class
* Methods
* class fields
* [http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces]

Common languages that exhibit reflection to varying degrees are Ruby, Java, Smalltalk, C# and more.

== Types of reflection ==
There are two basic types of reflection. They are:
* Behavioral Reflection: This type of reflection changes the behaviour of the execution of the program based on observation and modification.
* Structural Reflection: This type of reflection deals with changing the very structure of the program such as the data structures and flow of control in the program.

==Implementation==
There are many challenges faced by designers of reflective languages. They must provide as much leeway as possible for late binging and at the same time they must optimize the compilation of the static components so that they are ready for run-time. Reflection is in essense a connection between the object-level (program) and meta-level (the processor). The ability of the object level to be able to observe and modify the meta-level information is the consequence of this connection. These actions can be termed as [http://en.wikipedia.org/wiki/Type_introspection introspection] (This involves the action of observing the class) and intercession (this involves the operation of modifying the behavior of the class). These actions can implemented with the implementation of the following components:

* Ability to create [http://en.wikipedia.org/wiki/First-class_object first class objects] ie [http://en.wikipedia.org/wiki/Reification_(computer_science) reification].

* Ability to convert a string that denotes a class or a method into its corresponding reference or invocation.

* Ability to use and create symbolic links to methods and classes.

==Reflection by example==
===C#===
<pre>
int val = 20;
System.Type type = val.GetType();
System.Console.WriteLine(type);
</pre>
Output is type of the variable "val" = System.Int32

===Smalltalk===
<pre>
w := Workspace new.
w openLabel:'My Workspace'
w inspect
</pre>
Here we can inspect all the methods available to the instance 'w'.

===Java===
<pre>
import java.lang.reflect.*;
public class Fclass{
public static void main(String[] args){
Class cls = java.lang.Integer.class;
String info;
info = cls.getName(); // It will show java.lang.Integer
System.out.println(info);
}
}
</pre>
cls.getName() gives the complete class name which is printed out as the output of the above code is "java.lang.Integer"

===PHP===
<pre>
$reflector = new ReflectionClass("SimpleXMLElement");
echo $reflector;
</pre>
Output of this example is the complete class map of the class SimpleXMLElement.

==Dynamic binding : Making reflection possible==

Ruby implements [http://en.wikipedia.org/wiki/Dynamic_dispatch dynamic binding] of objects. Dynamic binding plays a very important role in [http://en.wikipedia.org/wiki/Metaprogramming meta-programming].

In languages like C,C++; a simple assignment "a = b", would require 'a' and 'b' to be of the same type. The assignment is interpreted as copying b into a and is implemented by copying the contents of b into the space occupied by a. Thus if 'a' had been declared as an object whose memory size is less than b's object, then object slicing takes place i.e. only that part of 'b' which fits into a's memory would be copied. This behavior might lead to unintended consequences.

[[File:Slicing.gif]]

But dynamic binding in Ruby ensures that the type of object stored in a variable is determined at run time and not at compile time. Thus the assignment "a = b" is interpreted as binding 'a' to the same object that 'b' is bound to. It is implemented by copying the reference stored in b into the (pointer-sized) memory cell of 'a'. Thus 'a' and 'b' point to the same object after the assignment.

[[File:Before_binding.png]] [[File:After_binding.png]]

==Symbols and their usage in reflection techniques==

===Basics===
[http://en.wikipedia.org/wiki/Symbol_%28programming%29 Symbols] are objects used to represent names and strings inside a Ruby [http://en.wikipedia.org/wiki/Interpreter_%28computing%29 interpreter]. They are immutable and remain unique i.e. every instance of a particular symbol is the same symbol.

===Usage in reflection techniques===
Symbols are widely used in reflection to invoke methods dynamically. Reflection methods like 'respond_to', 'send' make use of symbols as a reference to other methods. Strings can also be used in place of symbols. However symbols are more efficient compared to strings in terms of memory and performance.

===Examples===

====Passing method by reference using a symbol====
<pre>
class Float
def poly
self*self*self + 2*self*self + 3*self + 4
end
end
</pre>
And we can pass poly to an integration routine:
<pre>
area = integrate(:poly, 0, 10)
</pre>

====Symbols in reflection====
[http://ruby-doc.org/core-1.9.2/Object.html#method-i-send Send] method

<pre>
irb(main):015:0> to = [:to_s , :to_f]
=> [:to_s, :to_f]
irb(main):016:0> to.each{|method| puts "#{method} => #{5.send method}"}
to_s => 5
to_f => 5.0
=> [:to_s, :to_f]
</pre>

[http://ruby-doc.org/core-1.9.2/Object.html#method-i-respond_to-3F respond_to] method

<pre>
5.respond_to? :slice #=> false
5.respond_to? :to_f #=> true
</pre>
<pre>
obj = Object.new
if obj.respond_to?(:program)
obj.program
else
puts "Sorry, the object doesn't understand the 'program' message."
end
</pre>

==method_missing==

Whenever a call to a method is made on an object , Ruby does a method look up. If the method is not found, Ruby calls a method named '[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]'. Ruby knows the existence of the 'method_missing' as all objects are instances of 'BasicObject' which includes 'method_missing'. The default behavior of BasicObject#method_missing is to respond by raising a [http://www.ruby-doc.org/core-1.9.2/NoMethodError.html NoMethodError].

[http://en.wikipedia.org/wiki/Method_overriding Overriding] 'method_missing' allows users to call methods that don't really exist. The example below illustrates overriding of 'method_missing' to the programmer's advantage. Ruby passes as parameters the name of the method called and the arguments passed to it.

'''Example1'''
<pre>
class Cat
def mew
puts "Meow"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
c = Cat.new
c.mew
>>Meow
c.bark
>> Sorry, I do not bark
</pre>

In the above example, as the method 'bark' does not exist, method_missing is called with the meth (method name as a symbol) :bark. Hence the result " Sorry, I do not bark "

'''Example2'''
Using method_missing to convert Roman numerals <ref>http://www.rubyquiz.com/quiz22.html</ref> to integers

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end
</pre>

Evaluating Roman.xix calls the xix method of module Roman. Roman has no xix method, so method_missing is invoked with :xix as the argument.The id2name method of class Symbol is invoked on xix returning "xix". The "xix" is then parsed according to the rules for evaluating Roman numerals, and evaluates to 19.

''' Example 3 '''
<pre>
class Performer
def method_missing(name, *args)
"The duck will #{name}: #{args[0]}"
end
end

duck = Performer.new
duck.sing("Quacking in the Rain") # => "The duck will sing: Quacking in the Rain"
duck.dance("Swan Lake") # => "The duck will dance: Swan Lake"
</pre>

==Applications of Reflection==
*Reflection has become invaluable to programmers who need to connect code with data. For example in a GUI environment a button might need to invoke different methods in different classes. Reflection can be used here to call the method on any given class.

*Programmers who deal with a multitude of classes at the same time can use reflection to create a “serializer” that for a given class uses reflection to go through all the instance variables and processes them accordingly.

*Reflection is used in large test frameworks where reflection helps in identifying the test methods for different scenarios.

*Reflection provides the ability to morph the code based on dynamic situations. This provides a sense of artificial intelligence to the program as whole.

*Reflection can be used to debug and verify code as it provides access to the insides of a program.

*Reflection is very useful when the software is upgraded regularly. It provides an easy method to check for available methods and classes. This prevents the errors caused by the absense of methods and classes when they are deprecated.

==Advantages and disadvantages of reflection==

===Advantages===
* Extensibility: Reflection provides the capability of using external and user defined classes by instantiation of extensibility objects using their fully qualified names.
* Class browsers in IDEs: The ability to examine the members of classes makes implementation of visual aids , auto-completion and documentation easy in development tools for programmers.
* Debugging: Reflection allows the user to observe the private members in classes. This capability can be used to debug classes and their interactions.
* Test Harness : Reflection can be used to call a set of testing APIs defined on a class for maximum coverage of testing.
* Correctness : Reflection improves the robustness and the correctness of a program especially in dynamically typed languages as runtime checks can be added to check the availability of the methods or classes.

===Disadvantages===
* Reflection introduces lot of performance overhead when compared to non-reflective code. Hence it should be used judiciously.
* Since it provides access to the internals of a class or an encapsulated object security becomes a major issue.
* Since it is run-time binding we lose the security of compile time checks and verification.

==Conclusion==
This article makes an attempt to explain the concept of Reflection in Object Oriented Programming. The article mentions the different approaches to reflection in Ruby and other languages.It mentions the usage of Reflections and the advantages and disadvantages of using Reflection. A follow up to this article would be to study the concept of [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming].

==References==
<references/>

==Additional Reading==
*[http://en.wikipedia.org/wiki/Reflection_(computer_programming) Reflection]
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]
*[http://tutorials.jenkov.com/java-reflection/classes.html Java Reflection]
*[http://www.slideshare.net/CiaranMcHale/java-reflection-explained-simply Java reflection basics]
*[http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/malenfant/ref96/ref96.html A Tutorial on Behavioral Reflection and its Implementation]
*[http://www.quora.com/Computer-Programming/How-is-reflection-useful Uses of reflection]
*[http://download.oracle.com/javase/tutorial/reflect/index.html Java reflection official website]
*[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Ruby Documentation]

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-21T01:43:56Z

Sramach5: /* Additional Reading */

==Introduction==
Reflection is a relatively common computer programming concept where in the program has the inherant ability to examine itself at runtime. Based on its observations the program can modify it's behaviour for the given situation.The modifications can be any aspect of the programming language .i.e syntax, semantics, or implementation.

Reflection as a concept was first introduced in the doctoral dissertation of Dr. Brian Cantwell Smith in 1992.

==Reflection==
Reflection is the ability of a program or a computation to examine and modify itself at run time even though it does not have enough information at compile time. For example in a high level object oriented language the ability to inspect its class , interfaces and methods at run time without knowing their names at compile time. It provides the ability to modify , instantiate and access to methods such as getter's and setter's of a class. Since the program need not have all the information at compile time it makes the program more dynamic.

In the simple illustration provided below in ruby we can see how the name of a class can be obtained from the object and how we can get the ancestor classes and modules of a particular class.
<pre>

5.class #=> Fixnum

"hello".class #=> String

String.ancestors #=> [String, Enumerable, Comparable, Object, Kernel]

</pre>
Some of the common information that can be obtained from reflection are :
* Object type
* Super classes of any class
* Methods
* class fields
* Interfaces

Common languages that exhibit reflection to varying degrees are Ruby, Java, Smalltalk, C# and more.

== Types of reflection ==
There are two basic types of reflection. They are:
* Behavioral Reflection: This type of reflection changes the behaviour of the execution of the program based on observation and modification.
* Structural Reflection: This type of reflection deals with changing the very structure of the program such as the data structures and flow of control in the program.

==Implementation==
There are many challenges faced by designers of reflective languages. They must provide as much leeway as possible for late binging and at the same time they must optimize the compilation of the static components so that they are ready for run-time. Reflection is in essense a connection between the object-level (program) and meta-level (the processor). The ability of the object level to be able to observe and modify the meta-level information is the consequence of this connection. These actions can be termed as introspection and intercession. These actions can implemented with the implementation of the following components:

* Ability to create [http://en.wikipedia.org/wiki/First-class_object first class objects] ie [http://en.wikipedia.org/wiki/Reification_(computer_science) reification].

* Ability to convert a string that denotes a class or a method into its corresponding reference or invocation.

* Ability to use and create symbolic links to methods and classes.

==Reflection by example==
===C#===
<pre>
int val = 20;
System.Type type = val.GetType();
System.Console.WriteLine(type);
</pre>
Output is type of the variable "val" = System.Int32

===Smalltalk===
<pre>
w := Workspace new.
w openLabel:'My Workspace'
w inspect
</pre>
Here we can inspect all the methods available to the instance 'w'.

===Java===
<pre>
import java.lang.reflect.*;
public class Fclass{
public static void main(String[] args){
Class cls = java.lang.Integer.class;
String info;
info = cls.getName(); // It will show java.lang.Integer
System.out.println(info);
}
}
</pre>
cls.getName() gives the complete class name which is printed out as the output of the above code is "java.lang.Integer"

===PHP===
<pre>
$reflector = new ReflectionClass("SimpleXMLElement");
echo $reflector;
</pre>
Output of this example is the complete class map of the class SimpleXMLElement.

==Dynamic binding : Making reflection possible==

Ruby implements dynamic binding of objects. Dynamic binding plays a very important role in metaprogramming.

In languages like C,C++; a simple assignment "a = b", would require 'a' and 'b' to be of the same type. The assignment is interpreted as copying b into a and is implemented by copying the contents of b into the space occupied by a. Thus if 'a' had been declared as an object whose memory size is less than b's object, then object slicing takes place i.e. only that part of 'b' which fits into a's memory would be copied. This behavior might lead to unintended consequences.

But dynamic binding in Ruby ensures that the type of object stored in a variable is determined at run time and not at compile time. Thus the assignment "a = b" is interpreted as binding 'a' to the same object that 'b' is bound to. It is implemented by copying the reference stored in b into the (pointer-sized) memory cell of 'a'. Thus 'a' and 'b' point to the same object after the assignment.

==Symbols and their usage in reflection techniques==

===Basics===
Symbols are objects used to represent names and strings inside a Ruby interpreter. They are immutable and remain unique i.e. every instance of a particular symbol is the same symbol.

===Usage in reflection techniques===
Symbols are widely used in reflection to invoke methods dynamically. Reflection methods like 'respond_to', 'send' make use of symbols as a reference to other methods. Strings can also be used in place of symbols. However symbols are more efficient compared to strings in terms of memory and performance.

===Examples===

====Passing method by reference using a symbol====
<pre>
class Float
def poly
self*self*self + 2*self*self + 3*self + 4
end
end
</pre>
And we can pass poly to an integration routine:
<pre>
area = integrate(:poly, 0, 10)
</pre>

====Symbols in reflection====
Send method

<pre>
irb(main):015:0> to = [:to_s , :to_f]
=> [:to_s, :to_f]
irb(main):016:0> to.each{|method| puts "#{method} => #{5.send method}"}
to_s => 5
to_f => 5.0
=> [:to_s, :to_f]
</pre>

respond_to method

<pre>
5.respond_to? :slice #=> false
5.respond_to? :to_f #=> true
</pre>

==method_missing==

Whenever a call to a method is made on an object , Ruby does a method look up. If the method is not found, Ruby calls a method named 'method_missing'. Ruby knows the existence of the 'method_missing' as all objects are instances of 'BasicObject' which includes 'method_missing'. The default behavior of BasicObject#method_missing is to respond by raising a NoMethodError.

Overriding 'method_missing' allows users to call methods that don't really exist. The example below illustrates overriding of 'method_missing' to the programmer's advantage. Ruby passes as parameters the name of the method called and the arguments passed to it.

===Example1===
<pre>
class Cat
def mew
puts "Meow"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
c = Cat.new
c.mew
>>Meow
c.bark
>> Sorry, I do not bark
</pre>

In the above example, as the method 'bark' does not exist, method_missing is called with the meth (method name as a symbol) :bark. Hence the result " Sorry, I do not bark "

===Example2===
Using method_missing to convert Roman numerals to integers

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

</pre>

Evaluating Roman.xix calls the xix method of module Roman. Roman has no xix method, so method_missing is invoked with :xix as the argument.The id2name method of class Symbol is invoked on xix returning "xix". The "xix" is then parsed according to the rules for evaluating Roman numerals, and evaluates to 19.

==Applications of Reflection==
*Reflection has become invaluable to programmers who need to connect code with data. For example in a GUI environment a button might need to invoke different methods in different classes. Reflection can be used here to call the method on any given class.

*Programmers who deal with a multitude of classes at the same time can use reflection to create a “serializer” that for a given class uses reflection to go through all the instance variables and processes them accordingly.

*Reflection is used in large test frameworks where reflection helps in identifying the test methods for different scenarios.

*Reflection provides the ability to morph the code based on dynamic situations. This provides a sense of artificial intelligence to the program as whole.

*Reflection can be used to debug and verify code as it provides access to the insides of a program.

*Reflection is very useful when the software is upgraded regularly. It provides an easy method to check for available methods and classes. This prevents the errors caused by the absense of methods and classes when they are deprecated.

==Advantages and disadvantages of reflection==

===Advantages===
* Extensibility: Reflection provides the capability of using external and user defined classes by instantiation of extensibility objects using their fully qualified names.
* Class browsers in IDEs: The ability to examine the members of classes makes implementation of visual aids , auto-completion and documentation easy in development tools for programmers.
* Debugging: Reflection allows the user to observe the private members in classes. This capability can be used to debug classes and their interactions.
* Test Harness : Reflection can be used to call a set of testing APIs defined on a class for maximum coverage of testing.
* Correctness : Reflection improves the robustness and the correctness of a program especially in dynamically typed languages as runtime checks can be added to check the availability of the methods or classes.

===Disadvantages===
* Reflection introduces lot of performance overhead when compared to non-reflective code. Hence it should be used judiciously.
* Since it provides access to the internals of a class or an encapsulated object security becomes a major issue.
* Since it is run-time binding we lose the security of compile time checks and verification.

==Additional Reading==
*[http://en.wikipedia.org/wiki/Reflection_(computer_programming) Reflection]
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]
*[http://tutorials.jenkov.com/java-reflection/classes.html Java Reflection]
*[http://www.slideshare.net/CiaranMcHale/java-reflection-explained-simply Java reflection basics]
*[http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/malenfant/ref96/ref96.html A Tutorial on Behavioral Reflection and its Implementation]
*[http://www.quora.com/Computer-Programming/How-is-reflection-useful Uses of reflection]
*[http://download.oracle.com/javase/tutorial/reflect/index.html Java reflection official website]

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-21T00:20:54Z

Sramach5: /* Advantages and disadvantages of refletion */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T23:56:37Z

Sramach5: /* Java */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T23:55:30Z

Sramach5: /* Smalltalk */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T23:53:45Z

Sramach5: /* Advantages */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T19:31:56Z

Sramach5: /* Reflection by example */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T19:26:36Z

Sramach5: /* Reflection by example */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T19:24:26Z

Sramach5: /* = */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T19:24:08Z

Sramach5: /* Reflection by example */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T19:23:21Z

Sramach5: /* C# */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T18:41:57Z

Sramach5: /* Reflection by example */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T17:35:10Z

Sramach5: /* Types of reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T17:30:58Z

Sramach5: /* Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T16:07:37Z

Sramach5: /* Types of reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T15:51:01Z

Sramach5: /* Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:52:21Z

Sramach5: /* Implementation */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:51:20Z

Sramach5: /* Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:50:46Z

Sramach5: /* Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:43:26Z

Sramach5: /* Implementation */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:41:02Z

Sramach5: /* Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:36:39Z

Sramach5: /* Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:35:11Z

Sramach5: /* Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:24:56Z

Sramach5: /* Applications of Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:18:52Z

Sramach5: /* Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:13:30Z

Sramach5: /* Disadvantages */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:13:08Z

Sramach5: /* Advantages */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:12:34Z

Sramach5: /* Implementation */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:11:29Z

Sramach5: /* Advantages and disadvantages of refletion */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:10:37Z

Sramach5: /* Applications of Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:08:48Z

Sramach5: /* Implementation */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:07:51Z

Sramach5: /* Reflection */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T14:06:13Z

Sramach5: /* Introduction */

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T13:41:55Z

Sramach5: /* Introduction */

==Introduction==
Reflection is a relatively common computer programming concept where in the program has the inherant ability to examine itself at runtime. Based on its observations the program can modify it's behaviour for the given situation.

==Reflection==
==Implementation==
==Reflection by example==
==Applications of Reflection==
==Advantages and disadvantages of refletion==
==Additional Reading==

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T13:37:46Z

Sramach5: /* Introduction */

==Introduction==

==Reflection==
==Implementation==
==Reflection by example==
==Applications of Reflection==
==Advantages and disadvantages of refletion==
==Additional Reading==

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T13:34:22Z

Sramach5: /* Introduction */

==Introduction==
==Reflection==
==Implementation==
==Reflection by example==
==Applications of Reflection==
==Advantages and disadvantages of refletion==
==Additional Reading==

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T13:31:22Z

Sramach5: /* Introduction */

==Introduction==

CSC/ECE 517 Fall 2011/ch4 4f rs

2011-10-20T13:29:40Z

Sramach5: Created page with "=Introduction="

=Introduction=

CSC/ECE 517 Fall 2011

2011-10-20T13:27:32Z

Sramach5:

[[Link title]]
*[[CSC/ECE 517 Fall 2011/ch1 1a ms]]

*[[CSC/ECE 517 Fall 2011/ch1 1a cs]]

*[[CSC/ECE 517 Fall 2011/ch1 1a ri]]

*[[CSC/ECE 517 Fall 2011/ch1 1a lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1b sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1b ds]]

*[[CSC/ECE 517 Fall 2011/ch1 1b tj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c cm]]

*[[CSC/ECE 517 Fall 2011/ch1 1c sj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c ka]]

*[[CSC/ECE 517 Fall 2011/ch1 1d sr]]

*[[CSC/ECE 517 Fall 2011/ch1 1e vs]]

*[[CSC/ECE 517 Fall 2011/ch1 1e aa]]

*[[CSC/ECE 517 Fall 2011/ch1 1a sc]]

*[[CSC/ECE 517 Fall 2011/ch1 1e dm]]

*[[CSC/ECE 517 Fall 2011/ch1 1e an]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1e lm]]

*[[CSC/ECE 517 Fall 2011/ch1 1g vn]]

*[[CSC/ECE 517 Fall 2011/ch1 1f rs]]

*[[CSC/ECE 517 Fall 2011/ch1 1f sv]]

*[[CSC/ECE 517 Fall 2011/ch1 1g jn]]

*[[CSC/ECE 517 Fall 2011/ch1 1h ps]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sm]]

*[[CSC/ECE 517 Fall 2011/ch1 1i zf]]

*[[CSC/ECE 517 Fall 2011/ch1 1g rn]]

*[[CSC/ECE 517 Fall 2011/ch1 1i cl]]

*[[CSC/ECE 517 Fall 2011/ch1 1d ss]]

*[[CSC/ECE 517 Fall 2011/ch1 1i lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1h hs]]

*[[CSC/ECE 517 Fall 2011/ch1 1d gs]]

*[[CSC/ECE 517 Fall 2011/ch1 2b ns]]

*[[CSC/ECE 517 Fall 2011/ch1 2b jp]]

*[[CSC/ECE 517 Fall 2011/ch1 2a av]]

*[[CSC/ECE 517 Fall 2011/ch2 2f jm]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ad]]

*[[CSC/ECE 517 Fall 2011/ch2 2e kt]]

*[[CSC/ECE 517 Fall 2011/ch2 2e gp]]

*[[CSC/ECE 517 Fall 2011/ch1 2b qu]]

*[[CSC/ECE 517 Fall 2011/ch2 2c bs]]

*[[CSC/ECE 517 Fall 2011/ch1 2c rs]]

*[[CSC/ECE 517 Fall 2011/ch1 2a ca]]

*[[CSC/ECE 517 Fall 2011/ch1 2b rv]]

*[[CSC/ECE 517 Fall 2011/ch2 2c ds]]

*[[CSC/ECE 517 Fall 2011/ch2 2b sa]]

*[[CSC/ECE 517 Fall 2011/ch2 2f vh]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ps]]

*[[CSC/ECE 517 Fall 2011/ch3 3a oe]]

*[[CSC/ECE 517 Fall 2011/ch3 3h rr]]

*[[CSC/ECE 517 Fall 2011/ch3 3h ss]]

*[[CSC/ECE 517 Fall 2011/ch3 4b js]]

*[[CSC/ECE 517 Fall 2011/ch3 4b ms]]

*[[CSC/ECE 517 Fall 2011/ch4 4b ds]]

*[[CSC/ECE 517 Fall 2011/ch4 4i aa]]

*[[CSC/ECE 517 Fall 2011/ch4 4i sd]]

*[[CSC/ECE 517 Fall 2011/ch4 4d mt]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ls]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ch]]

*[[CSC/ECE 517 Fall 2011/ch4 4c ap]]

*[[CSC/ECE 517 Fall 2011/ch4 4h sv]]

*[[CSC/ECE 517 Fall 2011/ch4 4e cl]]

*[[CSC/ECE 517 Fall 2011/ch4 4a ga]]

*[[CSC/ECE 517 Fall 2011/ch4 4f sl]]

*[[CSC/ECE 517 Fall 2011/ch4 4i js]]

*[[CSC/ECE 517 Fall 2011/ch4 4f ss]]

*[[CSC/ECE 517 Fall 2011/ch4 4c dm]]

*[[CSC/ECE 517 Fall 2011/ch4 4g nv]]

*[[CSC/ECE 517 Fall 2011/ch4 4j fw]]

*[[CSC/ECE 517 Fall 2011/ch4 4f rs]]

*[[trial]]

CSC/ECE 517 Fall 2011/ch1 1e sa

2011-09-15T21:02:36Z

Sramach5: /* Block Structured code example */

"'''Block vs Object-Oriented Programming Languages'''"

In computer science, computer programming languages exhibit variance in syntax and structure in order to effectively solve problems. Two of these variances can be seen between '''block structure''' and '''object-oriented structure'''. A programming language with block structure allows the programmer to group lines of code for convenient use throughout the rest of the program. Object-oriented structure meanwhile goes further to allow the programmer to associate data with its actions in a hierarchical manner. Object-oriented structure has many advantages which generally make it more effective and durable than block-structured languages, but object-oriented languages also benefit from the core ideas present in block structure programming.

==Block structure==
===Definition===
Block-structured programming languages are task-centric, high-level languages. Operations on data sets are emphasized in an attempt to logically organize program operation. The design and implementation involves breaking down the problem into discrete blocks or units which can be nested to any depth or not at all. Each block generally consists of a set of delimiters such as braces or keywords that separate them from other blocks. Each of these blocks contains a set of (optional) declarations and logic to solve a particular problem. Declarations inside of nested blocks introduces the concept of variable scope, which frees the programmer from having to worry about name collisions and other variable maintenance tasks.<ref>[http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] at Wikipedia</ref> A [[CSC/ECE_517_Fall_2011/ch1_1e_sa#C.2FC.2B.2B_Code_Example|code example]] of a block structured program is provided later in the article.

Overall, block-structured languages can be summarized as having the following features:
* Modular - Lines of code/functionality are grouped together
* Scoped - Variables are limited to the group of code they are declared in
* [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Top down] - Modules are created as necessary to meet the program's requirements
* Simple - It is generally simpler to "cobble together" modules of code that accomplish a simple, well-defined task.

===History===
Block-structured languages were first conceived in the 1950s with the advent of [http://en.wikipedia.org/wiki/ALGOL ALGOL], one of the first [http://en.wikipedia.org/wiki/Imperative_programming imperative programming languages]. An evolution of block structuring was created as the "GOTO" logic of programs became more and more difficult to understand and maintain. In 1968, famed computer scientist [http://en.wikipedia.org/wiki/Edsger_W._Dijkstra Edsger Dijkstra] wrote [http://dx.doi.org/10.1145%2F362929.362947 a letter] and [http://dx.doi.org/10.1145%2F355604.361591 follow-up article] on the ideas and motivation behind "[http://en.wikipedia.org/wiki/Structured_programming structured programming]," where the program exhibits “[http://en.wikipedia.org/wiki/Separation_of_concerns separation of concerns]," single point of entry but multiple points of exit, and ideas of data structures. It was Dijkstra’s and others’ which helped propel this basic idea of block structure programming into the mainstream.<ref>[http://en.wikipedia.org/wiki/Structured_programming Structured programming] at Wikipedia</ref>

===Programming languages===
Block-structured programming languages dominate the general purpose, imperative programming language arena. Indeed most programming languages in modern use enjoy some of the benefits of block structure with grouping of code and scope of variables. Indeed, ignoring their object-oriented aspects, all of [http://en.wikipedia.org/wiki/C_(programming_language) C], [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#], [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/PHP PHP] and [http://en.wikipedia.org/wiki/Visual_Basic Visual Basic] – for example – contain elements of block structure.
====Block Structured code example====
The code snippet given below is an ALGOL example that calculates the mean.
<pre>
begin
integer N;
Read Int(N);

begin
real array Data[1:N];
real sum, avg;
integer i;
sum:=0;

for i:=1 step 1 until N do
begin real val;
Read Real(val);
Data[i]:=if val<0 then -val else val
end;

for i:=1 step 1 until N do
sum:=sum + Data[i];
avg:=sum/N;
Print Real(avg)
end
end
</pre>

==Object-oriented structure==
===Definition===
Object-oriented languages have an important overall goal and foster major design principles.
====Description====
Object-oriented structured languages are data-centric, high-level languages. This is in contrast to block structure languages, which are task-centric. Compared to block-structure languages, logical organization of data and the methods associated with them are emphasized. It is a way of grouping data with executable code. These groups are called "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]." Objects utilize their data and interact with other objects such that a hierarchy is established (called "[http://en.wikipedia.org/wiki/Class_(computer_science) classes]" in popular languages). Toward this end and depending on the language, objects can be interrelated and defined so that their relationships can produce code that is well-organized, easy to read, and reusable.<ref name="oopref">[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] at Wikipedia</ref>

====Principles====
=====Encapsulation=====
Also referred to as "data hiding," [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation] shields the programmer from the implementation details of an object. These implementation details would include [http://en.wikipedia.org/wiki/Local_variable private variables], special [http://en.wikipedia.org/wiki/Library_(computing) libraries], and [http://en.wikipedia.org/wiki/Data_structure data structures] that the programmer does not need to know in order to utilize the functionality offered by the object.<ref>[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation (object-oriented programming)] at Wikipedia</ref>

=====Inheritance=====
[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] introduces the idea of objects sharing functionality in data or methods that are common. [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses Subclasses] can inherit data structures, functions, and attributes of their [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses superclasses] in order to create an object or [http://en.wikipedia.org/wiki/Class_hierarchy class hierarchy] that is effective in organizing data and methods in a logical manner.<ref>[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance (computer science)] at Wikipedia</ref>

=====Polymorphism=====
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] describes the idea of interfaces, where one data type can be defined that allows other dissimilar types to implement a common set of [http://en.wikipedia.org/wiki/Method_(computer_programming) methods] and [http://en.wikipedia.org/wiki/Field_(computer_science) fields]. This allows a high level of [http://en.wikipedia.org/wiki/Abstraction_(computer_science) abstraction] that allows programmers to write easily maintainable code.<ref>[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism in object-oriented programming] at Wikipedia</ref>

===History and transition===
Early forms of object oriented programming languages were created in the early 1960s with the creation of [http://en.wikipedia.org/wiki/Lisp_(programming_language) LISP] and an early form of ALGOL, with [http://en.wikipedia.org/wiki/Simula Simula 67] signaling the actual beginning of the object-oriented "revolution." The development of object-oriented languages progressed through other languages like [http://en.wikipedia.org/wiki/Simula Smalltalk] and the archetypal C++ to arrive at many of the object oriented languages we have today.<ref name="oopref"/> As processing capability has matured, so too have the capabilities of programming languages. More and more though, [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic programming languages] like [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] are being treated as "true" object-oriented languages because of their rapid prototpying ability and strong [http://en.wikipedia.org/wiki/Object-oriented_analysis_and_design object model].

===Programming languages===
A complete list of object oriented languages is outside the scope of this document, but some major examples are [http://en.wikipedia.org/wiki/Boo_(programming_language) Boo], C++, C#, [http://en.wikipedia.org/wiki/COBOL COBOL 2002], [http://en.wikipedia.org/wiki/F_Sharp_(programming_language) F#], [http://en.wikipedia.org/wiki/Fortran Fortran 2003], Java, [http://en.wikipedia.org/wiki/Matlab MATLAB], [http://en.wikipedia.org/wiki/Objective_c Objective-C], [http://en.wikipedia.org/wiki/PHP PHP 5], [http://en.wikipedia.org/wiki/Python_(programming_language) Python], Ruby, and Visual Basic.<ref>[http://en.wikipedia.org/wiki/List_of_object-oriented_programming_languages List of object-oriented programming languages] at Wikipedia</ref>
====Object-oriented code example====
The code snippet given below is a simple example from a purely object-oriented language called Ruby.
<pre>
class AdderGen
def initialize(n)
@classVar1 = lambda {|a| n+a}
@classVar2 = lambda {|a| a*a}
end
def addVal(a)
return @classVar1.call(a)
end
def squareVal(a)
return @classVar2.call(a)
end
end

a = AdderGen.new(5)
puts a.addVal(6)
</pre>

==Structure comparison==
===Advantages and disadvantages===
==== Block-structured languages ====
=====Advantages=====
* Simplicity
* Reduced coding and turnover time
* Dynamic lifetime of variables ([http://en.wikipedia.org/wiki/Scope_(computer_science) Scope]) provide efficient usage of memory since allocation and deletion occur at the entrance and exit of each block

=====Disadvantages=====
* Commercial projects are difficult to manage due to very large [http://en.wikipedia.org/wiki/Codebase codebase] sizes
* Reduced code [http://en.wikipedia.org/wiki/Reusability reusability]
* [http://en.wikipedia.org/wiki/Computer_security Security] concerns, espcially in the realm of [http://en.wikipedia.org/wiki/Array#In_computer_science arrays] and accessing [http://en.wikipedia.org/wiki/Value_(computer_science) elements] that are [http://en.wikipedia.org/wiki/Privilege_(computing) out of bounds]

====Object-Oriented languages====
=====Advantages=====
* The software objects model real world objects so program composition is well defined and structured
* Each object's definition and internal implementation is decoupled from other objects, making the system design inherently modular ([http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation])
* Adding new features becomes easier because of inheritance, allowing the new class to contain the new feature in addition to all old features from the inherited class
* [http://en.wikipedia.org/wiki/Debugging Debugging] is easier since each object's internal mechanisms are independent of each other, which helps in isolating errors and fixing them
* Enhanced code reusability

=====Disadvantages=====
* The complexity of object-oriented design becomes prohibitive when working on small projects
* Object-oriented programming paradigm is preferable for dynamic environments rather than simple environments
* Reduced time efficiency compared to block-structured languages

===Summary of important differences===
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"
|-
! Difference
! Block Structured Languages
! Object-Oriented Languages
|-
| '''Problem approach'''
| Top-down approach is followed
| [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Bottom-up] approach is followed
|-
| '''Problem focus'''
| Focus is on the [http://en.wikipedia.org/wiki/Algorithm#Computer_algorithms algorithm] to solve the problem
| Focus is on getting the object design right
|-
| '''View of data and functions'''
| Views data and functions as separate entities
| Views data and functions as single entity
|-
| '''Cost of maintenance'''
| Maintenance is costly
| Maintenance is relatively cheaper
|-
| '''Software reuse'''
| Software reuse is not possible
| Software reuse is possible
|-
| '''Abstraction'''
| Function abstraction is used
| Data abstraction is used
|}

===Effectiveness and durability of object oriented languages over block structured languages ===

Although block structured languages were simpler and faster for smaller projects, when it comes to large commercial undertaking the manpower and tools required to maintain the code base is very prohibitive. It was very difficult to fix issues, add new features, and at the same time to make sure that the integrity of the code base is intact. Many projects were perpetually stagnant at 90% completion with issues coming up at the eleventh hour. All these problems led to the hastening of the move to object-oriented languages which showed it had the solutions to all the problems that block structured languages could not solve. The following four points are the most important reasons why object-oriented languages were more effective and durable that block structured languages:
* Maintenance - In block structured languages, especially in large projects, system maintenance became a challenge. Object oriented languages could counter this by providing clear demarcation between the objects and making it easier to work on individual aspects of the system without disturbing the other components.
* [http://en.wikipedia.org/wiki/Information_hiding Data hiding] - In block structured language system the data usually has global scope. Hence it is very difficult to monitor or supervise data access. This was solved by object-oriented languages by providing data encapsulation. The data and the corresponding attributes are put into a nice little package that was much easier to control and monitor.
* Code reuse - Object oriented languages are proponents of code reuse. Hence the code size could be reduced sufficiently enough when it comes to large projects to warrant a shift from block structured to object oriented languages.
* Feature additions - Object oriented languages provide a very cost effective and safe way to add new features to the existing system without causing the whole system to collapse. This feature is very important for large scale software vendors who provide various customizations.

===Applicability between paradigms===
Object-oriented languages have solved many problems that block structured languages introduced. But all is not lost with block structured languages. They boast some very important features that are needed in any programming language. The simplicity and readability of code in block structured languages are enviable features indeed. Because of this very simplicity we find that block structured languages are very efficient in terms of speed and performance. Such a language would also provide the flexibility in moving legacy block structured systems to the object oriented paradigm seamlessly. A language that can capture both sides of the argument would be a formidable entry into the growing list of programming languages. This explains why we see C++ emerging as one of the most popular object oriented languages. It has both the block structured features of C and the object-oriented concepts built into it, thereby making it a very versatile and efficient programming language.

==C/C++ Code Example==
{{Expand section}}
Below is a code example highlighting key differences between a block structured program and an object oriented program all in one source file.
<pre>// For block structure, leave the below line commented to compile in C
// For object oriented structure, uncomment the line to compile in C++
//#define USING_CPP

#ifndef USING_CPP

// C standard header files
#include <stdio.h>
#include <stdlib.h>

// Define the messages of each persona
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Define the function prototypes for delivering the different messages
char *getKingMessage();
char *getJesterMessage();
char *getPeonMessage();

// Main program entry point
int main()
{
// Go through and make each function call for...
// The King
printf("And now a message from the king: %s\n", getKingMessage());
printf("The King has spoken!\n\n");

// The Court Jester
printf("And now a message from the court jester: %s\n", getJesterMessage());
printf("Wocka wocka wocka!\n\n");

// A Peon
printf("And now a message from a peon: %s\n", getPeonMessage());
printf("... but don't mind me!\n\n");

// Wait for user input before exiting
system("pause");

return 0;
}

// Returns a string containing the text to be spoken by the king
char *getKingMessage()
{
return KING_MESSAGE;
}

// Returns a string containing the text to be spoken by the court jester
char *getJesterMessage()
{
return JESTER_MESSAGE;
}

// Returns a string containing the text to be spoken by all peons
char *getPeonMessage()
{
return PEON_MESSAGE;
}
#endif

#ifdef USING_CPP

// C++ standard headers
#include <cstdio>
#include <cstdlib>

// Define what each persona should say
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Keep all classes clearly separated from other sections of code
namespace Monarchy
{
// Define a basic class where a person has a label and something they want to say
class Person
{
private:
char *szMessage;
char *szLabel;

public:
// Allow a person to deliver their message
void DeliverMessage()
{
printf("A now a message from %s: %s\n", this->szLabel, this->szMessage);
}

// A person needs to be initialized with a label and a message
Person(char*label, char *msg)
{
this->szLabel = label;
this->szMessage = msg;
}
};

// The King is a person (and thus inherits from it)
class King : public Person
{
public:
// The king has the same label, but his message might change according to the political winds
King(char *msg) : Person("the king", msg)
{
}

// Here, the function is being overridden...
void DeliverMessage()
{
// .. but the base class's DeliverMessage is still being called, in addition to the tag line
Person::DeliverMessage();
printf("The King has spoken!\n\n");
}
};

// A peon is a person (and thus inherits from it)
class Peon : public Person
{
public:
// A peon has the same label but his message might change according to his or her attitude toward the king
Peon(char *msg) : Person("a peon", msg)
{
}

// Like above, deliver the message, but always provide a common tag line
void DeliverMessage()
{
Person::DeliverMessage();
printf("... but don't mind me!\n\n");
}
};

// A jester is a person (and thus inherits from it)
class Jester : public Person
{
public:
// A peon has the same label but his message might change if the king is sick of his jokes
Jester(char *msg) : Person("the court jester", msg)
{
}

// Might as well call him Fozzie ;)
void DeliverMessage()
{
Person::DeliverMessage();
printf("Wocka wocka wocka!\n\n");
}
};
}

// Main program entry point
int main()
{
// Initialize some monarchy objects
Monarchy::King TheKing(KING_MESSAGE);
Monarchy::Jester Borat(JESTER_MESSAGE);
Monarchy::Peon Bruno(PEON_MESSAGE);

// Let them deliver their messages
TheKing.DeliverMessage();
Borat.DeliverMessage();
Bruno.DeliverMessage();

// Wait for user input
system("pause");

return 0;
}
#endif</pre>

==See also==
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Functional_programming Functional programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Programming_paradigm Programming paradigm] at Wikipedia
* [http://en.wikipedia.org/wiki/Class-based_programming Class-based programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Prototype-based_programming Prototype-based programming] at Wikipedia

==References==
<references/>

==Further reading==
* Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. ''Head First Design Patterns''. Sebastopol, CA: O'Reilly, 2004. Print.
* Liberty, Jesse. ''Sams Teach Yourself C++ in 24 Hours''. Indianapolis, IN: Sams, 2002. Print.
* ''Microsoft Visual C++ Language Reference''. Redmond, WA: Microsoft, 1997. Print.
* Weiss, Mark Allen. ''Data Structures & Algorithm Analysis in Java''. Reading, MA: Addison-Wesley, 1999. Print.
* Mohamed Fayad, Mauri Laitinen. "TRANSITION TO OBJECT-ORIENTED SOFTWARE DEVELOPMENT."

==External links==
* [http://www.slideshare.net/spajus/object-oriented-programming-presentation-933801 Object Oriented Programming] at slide'''share'''
* [http://www.developer.com/java/other/article.php/3493761/The-Evolution-of-Object-Oriented-Languages.htm The Evolution of Object-Oriented Languages]
* [http://www.xp2003.org/the-history-of-oop.htm The History of OOP]
* [http://www.brighthub.com/internet/web-development/articles/82024.aspx Structured vs. Object-Oriented Programming: A Comparison]

CSC/ECE 517 Fall 2011/ch1 1e sa

2011-09-15T21:01:42Z

Sramach5: /* Object-oriented structure */

"'''Block vs Object-Oriented Programming Languages'''"

In computer science, computer programming languages exhibit variance in syntax and structure in order to effectively solve problems. Two of these variances can be seen between '''block structure''' and '''object-oriented structure'''. A programming language with block structure allows the programmer to group lines of code for convenient use throughout the rest of the program. Object-oriented structure meanwhile goes further to allow the programmer to associate data with its actions in a hierarchical manner. Object-oriented structure has many advantages which generally make it more effective and durable than block-structured languages, but object-oriented languages also benefit from the core ideas present in block structure programming.

==Block structure==
===Definition===
Block-structured programming languages are task-centric, high-level languages. Operations on data sets are emphasized in an attempt to logically organize program operation. The design and implementation involves breaking down the problem into discrete blocks or units which can be nested to any depth or not at all. Each block generally consists of a set of delimiters such as braces or keywords that separate them from other blocks. Each of these blocks contains a set of (optional) declarations and logic to solve a particular problem. Declarations inside of nested blocks introduces the concept of variable scope, which frees the programmer from having to worry about name collisions and other variable maintenance tasks.<ref>[http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] at Wikipedia</ref> A [[CSC/ECE_517_Fall_2011/ch1_1e_sa#C.2FC.2B.2B_Code_Example|code example]] of a block structured program is provided later in the article.

Overall, block-structured languages can be summarized as having the following features:
* Modular - Lines of code/functionality are grouped together
* Scoped - Variables are limited to the group of code they are declared in
* [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Top down] - Modules are created as necessary to meet the program's requirements
* Simple - It is generally simpler to "cobble together" modules of code that accomplish a simple, well-defined task.

===History===
Block-structured languages were first conceived in the 1950s with the advent of [http://en.wikipedia.org/wiki/ALGOL ALGOL], one of the first [http://en.wikipedia.org/wiki/Imperative_programming imperative programming languages]. An evolution of block structuring was created as the "GOTO" logic of programs became more and more difficult to understand and maintain. In 1968, famed computer scientist [http://en.wikipedia.org/wiki/Edsger_W._Dijkstra Edsger Dijkstra] wrote [http://dx.doi.org/10.1145%2F362929.362947 a letter] and [http://dx.doi.org/10.1145%2F355604.361591 follow-up article] on the ideas and motivation behind "[http://en.wikipedia.org/wiki/Structured_programming structured programming]," where the program exhibits “[http://en.wikipedia.org/wiki/Separation_of_concerns separation of concerns]," single point of entry but multiple points of exit, and ideas of data structures. It was Dijkstra’s and others’ which helped propel this basic idea of block structure programming into the mainstream.<ref>[http://en.wikipedia.org/wiki/Structured_programming Structured programming] at Wikipedia</ref>

===Programming languages===
Block-structured programming languages dominate the general purpose, imperative programming language arena. Indeed most programming languages in modern use enjoy some of the benefits of block structure with grouping of code and scope of variables. Indeed, ignoring their object-oriented aspects, all of [http://en.wikipedia.org/wiki/C_(programming_language) C], [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#], [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/PHP PHP] and [http://en.wikipedia.org/wiki/Visual_Basic Visual Basic] – for example – contain elements of block structure.
====Block Structured code example====
<pre>
begin
integer N;
Read Int(N);

begin
real array Data[1:N];
real sum, avg;
integer i;
sum:=0;

for i:=1 step 1 until N do
begin real val;
Read Real(val);
Data[i]:=if val<0 then -val else val
end;

for i:=1 step 1 until N do
sum:=sum + Data[i];
avg:=sum/N;
Print Real(avg)
end
end
</pre>

==Object-oriented structure==
===Definition===
Object-oriented languages have an important overall goal and foster major design principles.
====Description====
Object-oriented structured languages are data-centric, high-level languages. This is in contrast to block structure languages, which are task-centric. Compared to block-structure languages, logical organization of data and the methods associated with them are emphasized. It is a way of grouping data with executable code. These groups are called "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]." Objects utilize their data and interact with other objects such that a hierarchy is established (called "[http://en.wikipedia.org/wiki/Class_(computer_science) classes]" in popular languages). Toward this end and depending on the language, objects can be interrelated and defined so that their relationships can produce code that is well-organized, easy to read, and reusable.<ref name="oopref">[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] at Wikipedia</ref>

====Principles====
=====Encapsulation=====
Also referred to as "data hiding," [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation] shields the programmer from the implementation details of an object. These implementation details would include [http://en.wikipedia.org/wiki/Local_variable private variables], special [http://en.wikipedia.org/wiki/Library_(computing) libraries], and [http://en.wikipedia.org/wiki/Data_structure data structures] that the programmer does not need to know in order to utilize the functionality offered by the object.<ref>[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation (object-oriented programming)] at Wikipedia</ref>

=====Inheritance=====
[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] introduces the idea of objects sharing functionality in data or methods that are common. [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses Subclasses] can inherit data structures, functions, and attributes of their [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses superclasses] in order to create an object or [http://en.wikipedia.org/wiki/Class_hierarchy class hierarchy] that is effective in organizing data and methods in a logical manner.<ref>[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance (computer science)] at Wikipedia</ref>

=====Polymorphism=====
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] describes the idea of interfaces, where one data type can be defined that allows other dissimilar types to implement a common set of [http://en.wikipedia.org/wiki/Method_(computer_programming) methods] and [http://en.wikipedia.org/wiki/Field_(computer_science) fields]. This allows a high level of [http://en.wikipedia.org/wiki/Abstraction_(computer_science) abstraction] that allows programmers to write easily maintainable code.<ref>[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism in object-oriented programming] at Wikipedia</ref>

===History and transition===
Early forms of object oriented programming languages were created in the early 1960s with the creation of [http://en.wikipedia.org/wiki/Lisp_(programming_language) LISP] and an early form of ALGOL, with [http://en.wikipedia.org/wiki/Simula Simula 67] signaling the actual beginning of the object-oriented "revolution." The development of object-oriented languages progressed through other languages like [http://en.wikipedia.org/wiki/Simula Smalltalk] and the archetypal C++ to arrive at many of the object oriented languages we have today.<ref name="oopref"/> As processing capability has matured, so too have the capabilities of programming languages. More and more though, [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic programming languages] like [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] are being treated as "true" object-oriented languages because of their rapid prototpying ability and strong [http://en.wikipedia.org/wiki/Object-oriented_analysis_and_design object model].

===Programming languages===
A complete list of object oriented languages is outside the scope of this document, but some major examples are [http://en.wikipedia.org/wiki/Boo_(programming_language) Boo], C++, C#, [http://en.wikipedia.org/wiki/COBOL COBOL 2002], [http://en.wikipedia.org/wiki/F_Sharp_(programming_language) F#], [http://en.wikipedia.org/wiki/Fortran Fortran 2003], Java, [http://en.wikipedia.org/wiki/Matlab MATLAB], [http://en.wikipedia.org/wiki/Objective_c Objective-C], [http://en.wikipedia.org/wiki/PHP PHP 5], [http://en.wikipedia.org/wiki/Python_(programming_language) Python], Ruby, and Visual Basic.<ref>[http://en.wikipedia.org/wiki/List_of_object-oriented_programming_languages List of object-oriented programming languages] at Wikipedia</ref>
====Object-oriented code example====
The code snippet given below is a simple example from a purely object-oriented language called Ruby.
<pre>
class AdderGen
def initialize(n)
@classVar1 = lambda {|a| n+a}
@classVar2 = lambda {|a| a*a}
end
def addVal(a)
return @classVar1.call(a)
end
def squareVal(a)
return @classVar2.call(a)
end
end

a = AdderGen.new(5)
puts a.addVal(6)
</pre>

==Structure comparison==
===Advantages and disadvantages===
==== Block-structured languages ====
=====Advantages=====
* Simplicity
* Reduced coding and turnover time
* Dynamic lifetime of variables ([http://en.wikipedia.org/wiki/Scope_(computer_science) Scope]) provide efficient usage of memory since allocation and deletion occur at the entrance and exit of each block

=====Disadvantages=====
* Commercial projects are difficult to manage due to very large [http://en.wikipedia.org/wiki/Codebase codebase] sizes
* Reduced code [http://en.wikipedia.org/wiki/Reusability reusability]
* [http://en.wikipedia.org/wiki/Computer_security Security] concerns, espcially in the realm of [http://en.wikipedia.org/wiki/Array#In_computer_science arrays] and accessing [http://en.wikipedia.org/wiki/Value_(computer_science) elements] that are [http://en.wikipedia.org/wiki/Privilege_(computing) out of bounds]

====Object-Oriented languages====
=====Advantages=====
* The software objects model real world objects so program composition is well defined and structured
* Each object's definition and internal implementation is decoupled from other objects, making the system design inherently modular ([http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation])
* Adding new features becomes easier because of inheritance, allowing the new class to contain the new feature in addition to all old features from the inherited class
* [http://en.wikipedia.org/wiki/Debugging Debugging] is easier since each object's internal mechanisms are independent of each other, which helps in isolating errors and fixing them
* Enhanced code reusability

=====Disadvantages=====
* The complexity of object-oriented design becomes prohibitive when working on small projects
* Object-oriented programming paradigm is preferable for dynamic environments rather than simple environments
* Reduced time efficiency compared to block-structured languages

===Summary of important differences===
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"
|-
! Difference
! Block Structured Languages
! Object-Oriented Languages
|-
| '''Problem approach'''
| Top-down approach is followed
| [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Bottom-up] approach is followed
|-
| '''Problem focus'''
| Focus is on the [http://en.wikipedia.org/wiki/Algorithm#Computer_algorithms algorithm] to solve the problem
| Focus is on getting the object design right
|-
| '''View of data and functions'''
| Views data and functions as separate entities
| Views data and functions as single entity
|-
| '''Cost of maintenance'''
| Maintenance is costly
| Maintenance is relatively cheaper
|-
| '''Software reuse'''
| Software reuse is not possible
| Software reuse is possible
|-
| '''Abstraction'''
| Function abstraction is used
| Data abstraction is used
|}

===Effectiveness and durability of object oriented languages over block structured languages ===

Although block structured languages were simpler and faster for smaller projects, when it comes to large commercial undertaking the manpower and tools required to maintain the code base is very prohibitive. It was very difficult to fix issues, add new features, and at the same time to make sure that the integrity of the code base is intact. Many projects were perpetually stagnant at 90% completion with issues coming up at the eleventh hour. All these problems led to the hastening of the move to object-oriented languages which showed it had the solutions to all the problems that block structured languages could not solve. The following four points are the most important reasons why object-oriented languages were more effective and durable that block structured languages:
* Maintenance - In block structured languages, especially in large projects, system maintenance became a challenge. Object oriented languages could counter this by providing clear demarcation between the objects and making it easier to work on individual aspects of the system without disturbing the other components.
* [http://en.wikipedia.org/wiki/Information_hiding Data hiding] - In block structured language system the data usually has global scope. Hence it is very difficult to monitor or supervise data access. This was solved by object-oriented languages by providing data encapsulation. The data and the corresponding attributes are put into a nice little package that was much easier to control and monitor.
* Code reuse - Object oriented languages are proponents of code reuse. Hence the code size could be reduced sufficiently enough when it comes to large projects to warrant a shift from block structured to object oriented languages.
* Feature additions - Object oriented languages provide a very cost effective and safe way to add new features to the existing system without causing the whole system to collapse. This feature is very important for large scale software vendors who provide various customizations.

===Applicability between paradigms===
Object-oriented languages have solved many problems that block structured languages introduced. But all is not lost with block structured languages. They boast some very important features that are needed in any programming language. The simplicity and readability of code in block structured languages are enviable features indeed. Because of this very simplicity we find that block structured languages are very efficient in terms of speed and performance. Such a language would also provide the flexibility in moving legacy block structured systems to the object oriented paradigm seamlessly. A language that can capture both sides of the argument would be a formidable entry into the growing list of programming languages. This explains why we see C++ emerging as one of the most popular object oriented languages. It has both the block structured features of C and the object-oriented concepts built into it, thereby making it a very versatile and efficient programming language.

==C/C++ Code Example==
{{Expand section}}
Below is a code example highlighting key differences between a block structured program and an object oriented program all in one source file.
<pre>// For block structure, leave the below line commented to compile in C
// For object oriented structure, uncomment the line to compile in C++
//#define USING_CPP

#ifndef USING_CPP

// C standard header files
#include <stdio.h>
#include <stdlib.h>

// Define the messages of each persona
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Define the function prototypes for delivering the different messages
char *getKingMessage();
char *getJesterMessage();
char *getPeonMessage();

// Main program entry point
int main()
{
// Go through and make each function call for...
// The King
printf("And now a message from the king: %s\n", getKingMessage());
printf("The King has spoken!\n\n");

// The Court Jester
printf("And now a message from the court jester: %s\n", getJesterMessage());
printf("Wocka wocka wocka!\n\n");

// A Peon
printf("And now a message from a peon: %s\n", getPeonMessage());
printf("... but don't mind me!\n\n");

// Wait for user input before exiting
system("pause");

return 0;
}

// Returns a string containing the text to be spoken by the king
char *getKingMessage()
{
return KING_MESSAGE;
}

// Returns a string containing the text to be spoken by the court jester
char *getJesterMessage()
{
return JESTER_MESSAGE;
}

// Returns a string containing the text to be spoken by all peons
char *getPeonMessage()
{
return PEON_MESSAGE;
}
#endif

#ifdef USING_CPP

// C++ standard headers
#include <cstdio>
#include <cstdlib>

// Define what each persona should say
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Keep all classes clearly separated from other sections of code
namespace Monarchy
{
// Define a basic class where a person has a label and something they want to say
class Person
{
private:
char *szMessage;
char *szLabel;

public:
// Allow a person to deliver their message
void DeliverMessage()
{
printf("A now a message from %s: %s\n", this->szLabel, this->szMessage);
}

// A person needs to be initialized with a label and a message
Person(char*label, char *msg)
{
this->szLabel = label;
this->szMessage = msg;
}
};

// The King is a person (and thus inherits from it)
class King : public Person
{
public:
// The king has the same label, but his message might change according to the political winds
King(char *msg) : Person("the king", msg)
{
}

// Here, the function is being overridden...
void DeliverMessage()
{
// .. but the base class's DeliverMessage is still being called, in addition to the tag line
Person::DeliverMessage();
printf("The King has spoken!\n\n");
}
};

// A peon is a person (and thus inherits from it)
class Peon : public Person
{
public:
// A peon has the same label but his message might change according to his or her attitude toward the king
Peon(char *msg) : Person("a peon", msg)
{
}

// Like above, deliver the message, but always provide a common tag line
void DeliverMessage()
{
Person::DeliverMessage();
printf("... but don't mind me!\n\n");
}
};

// A jester is a person (and thus inherits from it)
class Jester : public Person
{
public:
// A peon has the same label but his message might change if the king is sick of his jokes
Jester(char *msg) : Person("the court jester", msg)
{
}

// Might as well call him Fozzie ;)
void DeliverMessage()
{
Person::DeliverMessage();
printf("Wocka wocka wocka!\n\n");
}
};
}

// Main program entry point
int main()
{
// Initialize some monarchy objects
Monarchy::King TheKing(KING_MESSAGE);
Monarchy::Jester Borat(JESTER_MESSAGE);
Monarchy::Peon Bruno(PEON_MESSAGE);

// Let them deliver their messages
TheKing.DeliverMessage();
Borat.DeliverMessage();
Bruno.DeliverMessage();

// Wait for user input
system("pause");

return 0;
}
#endif</pre>

==See also==
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Functional_programming Functional programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Programming_paradigm Programming paradigm] at Wikipedia
* [http://en.wikipedia.org/wiki/Class-based_programming Class-based programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Prototype-based_programming Prototype-based programming] at Wikipedia

==References==
<references/>

==Further reading==
* Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. ''Head First Design Patterns''. Sebastopol, CA: O'Reilly, 2004. Print.
* Liberty, Jesse. ''Sams Teach Yourself C++ in 24 Hours''. Indianapolis, IN: Sams, 2002. Print.
* ''Microsoft Visual C++ Language Reference''. Redmond, WA: Microsoft, 1997. Print.
* Weiss, Mark Allen. ''Data Structures & Algorithm Analysis in Java''. Reading, MA: Addison-Wesley, 1999. Print.
* Mohamed Fayad, Mauri Laitinen. "TRANSITION TO OBJECT-ORIENTED SOFTWARE DEVELOPMENT."

==External links==
* [http://www.slideshare.net/spajus/object-oriented-programming-presentation-933801 Object Oriented Programming] at slide'''share'''
* [http://www.developer.com/java/other/article.php/3493761/The-Evolution-of-Object-Oriented-Languages.htm The Evolution of Object-Oriented Languages]
* [http://www.xp2003.org/the-history-of-oop.htm The History of OOP]
* [http://www.brighthub.com/internet/web-development/articles/82024.aspx Structured vs. Object-Oriented Programming: A Comparison]

CSC/ECE 517 Fall 2011/ch1 1e sa

2011-09-15T20:55:06Z

Sramach5: /* Block structure */

"'''Block vs Object-Oriented Programming Languages'''"

In computer science, computer programming languages exhibit variance in syntax and structure in order to effectively solve problems. Two of these variances can be seen between '''block structure''' and '''object-oriented structure'''. A programming language with block structure allows the programmer to group lines of code for convenient use throughout the rest of the program. Object-oriented structure meanwhile goes further to allow the programmer to associate data with its actions in a hierarchical manner. Object-oriented structure has many advantages which generally make it more effective and durable than block-structured languages, but object-oriented languages also benefit from the core ideas present in block structure programming.

==Block structure==
===Definition===
Block-structured programming languages are task-centric, high-level languages. Operations on data sets are emphasized in an attempt to logically organize program operation. The design and implementation involves breaking down the problem into discrete blocks or units which can be nested to any depth or not at all. Each block generally consists of a set of delimiters such as braces or keywords that separate them from other blocks. Each of these blocks contains a set of (optional) declarations and logic to solve a particular problem. Declarations inside of nested blocks introduces the concept of variable scope, which frees the programmer from having to worry about name collisions and other variable maintenance tasks.<ref>[http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] at Wikipedia</ref> A [[CSC/ECE_517_Fall_2011/ch1_1e_sa#C.2FC.2B.2B_Code_Example|code example]] of a block structured program is provided later in the article.

Overall, block-structured languages can be summarized as having the following features:
* Modular - Lines of code/functionality are grouped together
* Scoped - Variables are limited to the group of code they are declared in
* [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Top down] - Modules are created as necessary to meet the program's requirements
* Simple - It is generally simpler to "cobble together" modules of code that accomplish a simple, well-defined task.

===History===
Block-structured languages were first conceived in the 1950s with the advent of [http://en.wikipedia.org/wiki/ALGOL ALGOL], one of the first [http://en.wikipedia.org/wiki/Imperative_programming imperative programming languages]. An evolution of block structuring was created as the "GOTO" logic of programs became more and more difficult to understand and maintain. In 1968, famed computer scientist [http://en.wikipedia.org/wiki/Edsger_W._Dijkstra Edsger Dijkstra] wrote [http://dx.doi.org/10.1145%2F362929.362947 a letter] and [http://dx.doi.org/10.1145%2F355604.361591 follow-up article] on the ideas and motivation behind "[http://en.wikipedia.org/wiki/Structured_programming structured programming]," where the program exhibits “[http://en.wikipedia.org/wiki/Separation_of_concerns separation of concerns]," single point of entry but multiple points of exit, and ideas of data structures. It was Dijkstra’s and others’ which helped propel this basic idea of block structure programming into the mainstream.<ref>[http://en.wikipedia.org/wiki/Structured_programming Structured programming] at Wikipedia</ref>

===Programming languages===
Block-structured programming languages dominate the general purpose, imperative programming language arena. Indeed most programming languages in modern use enjoy some of the benefits of block structure with grouping of code and scope of variables. Indeed, ignoring their object-oriented aspects, all of [http://en.wikipedia.org/wiki/C_(programming_language) C], [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#], [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/PHP PHP] and [http://en.wikipedia.org/wiki/Visual_Basic Visual Basic] – for example – contain elements of block structure.
====Block Structured code example====
<pre>
begin
integer N;
Read Int(N);

begin
real array Data[1:N];
real sum, avg;
integer i;
sum:=0;

for i:=1 step 1 until N do
begin real val;
Read Real(val);
Data[i]:=if val<0 then -val else val
end;

for i:=1 step 1 until N do
sum:=sum + Data[i];
avg:=sum/N;
Print Real(avg)
end
end
</pre>

==Object-oriented structure==
===Definition===
Object-oriented languages have an important overall goal and foster major design principles.
====Description====
Object-oriented structured languages are data-centric, high-level languages. This is in contrast to block structure languages, which are task-centric. Compared to block-structure languages, logical organization of data and the methods associated with them are emphasized. It is a way of grouping data with executable code. These groups are called "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]." Objects utilize their data and interact with other objects such that a hierarchy is established (called "[http://en.wikipedia.org/wiki/Class_(computer_science) classes]" in popular languages). Toward this end and depending on the language, objects can be interrelated and defined so that their relationships can produce code that is well-organized, easy to read, and reusable.<ref name="oopref">[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] at Wikipedia</ref>

====Principles====
=====Encapsulation=====
Also referred to as "data hiding," [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation] shields the programmer from the implementation details of an object. These implementation details would include [http://en.wikipedia.org/wiki/Local_variable private variables], special [http://en.wikipedia.org/wiki/Library_(computing) libraries], and [http://en.wikipedia.org/wiki/Data_structure data structures] that the programmer does not need to know in order to utilize the functionality offered by the object.<ref>[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation (object-oriented programming)] at Wikipedia</ref>

=====Inheritance=====
[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] introduces the idea of objects sharing functionality in data or methods that are common. [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses Subclasses] can inherit data structures, functions, and attributes of their [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses superclasses] in order to create an object or [http://en.wikipedia.org/wiki/Class_hierarchy class hierarchy] that is effective in organizing data and methods in a logical manner.<ref>[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance (computer science)] at Wikipedia</ref>

=====Polymorphism=====
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] describes the idea of interfaces, where one data type can be defined that allows other dissimilar types to implement a common set of [http://en.wikipedia.org/wiki/Method_(computer_programming) methods] and [http://en.wikipedia.org/wiki/Field_(computer_science) fields]. This allows a high level of [http://en.wikipedia.org/wiki/Abstraction_(computer_science) abstraction] that allows programmers to write easily maintainable code.<ref>[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism in object-oriented programming] at Wikipedia</ref>

===History and transition===
Early forms of object oriented programming languages were created in the early 1960s with the creation of [http://en.wikipedia.org/wiki/Lisp_(programming_language) LISP] and an early form of ALGOL, with [http://en.wikipedia.org/wiki/Simula Simula 67] signaling the actual beginning of the object-oriented "revolution." The development of object-oriented languages progressed through other languages like [http://en.wikipedia.org/wiki/Simula Smalltalk] and the archetypal C++ to arrive at many of the object oriented languages we have today.<ref name="oopref"/> As processing capability has matured, so too have the capabilities of programming languages. More and more though, [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic programming languages] like [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] are being treated as "true" object-oriented languages because of their rapid prototpying ability and strong [http://en.wikipedia.org/wiki/Object-oriented_analysis_and_design object model].

===Programming languages===
A complete list of object oriented languages is outside the scope of this document, but some major examples are [http://en.wikipedia.org/wiki/Boo_(programming_language) Boo], C++, C#, [http://en.wikipedia.org/wiki/COBOL COBOL 2002], [http://en.wikipedia.org/wiki/F_Sharp_(programming_language) F#], [http://en.wikipedia.org/wiki/Fortran Fortran 2003], Java, [http://en.wikipedia.org/wiki/Matlab MATLAB], [http://en.wikipedia.org/wiki/Objective_c Objective-C], [http://en.wikipedia.org/wiki/PHP PHP 5], [http://en.wikipedia.org/wiki/Python_(programming_language) Python], Ruby, and Visual Basic.<ref>[http://en.wikipedia.org/wiki/List_of_object-oriented_programming_languages List of object-oriented programming languages] at Wikipedia</ref>

==Structure comparison==
===Advantages and disadvantages===
==== Block-structured languages ====
=====Advantages=====
* Simplicity
* Reduced coding and turnover time
* Dynamic lifetime of variables ([http://en.wikipedia.org/wiki/Scope_(computer_science) Scope]) provide efficient usage of memory since allocation and deletion occur at the entrance and exit of each block

=====Disadvantages=====
* Commercial projects are difficult to manage due to very large [http://en.wikipedia.org/wiki/Codebase codebase] sizes
* Reduced code [http://en.wikipedia.org/wiki/Reusability reusability]
* [http://en.wikipedia.org/wiki/Computer_security Security] concerns, espcially in the realm of [http://en.wikipedia.org/wiki/Array#In_computer_science arrays] and accessing [http://en.wikipedia.org/wiki/Value_(computer_science) elements] that are [http://en.wikipedia.org/wiki/Privilege_(computing) out of bounds]

====Object-Oriented languages====
=====Advantages=====
* The software objects model real world objects so program composition is well defined and structured
* Each object's definition and internal implementation is decoupled from other objects, making the system design inherently modular ([http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation])
* Adding new features becomes easier because of inheritance, allowing the new class to contain the new feature in addition to all old features from the inherited class
* [http://en.wikipedia.org/wiki/Debugging Debugging] is easier since each object's internal mechanisms are independent of each other, which helps in isolating errors and fixing them
* Enhanced code reusability

=====Disadvantages=====
* The complexity of object-oriented design becomes prohibitive when working on small projects
* Object-oriented programming paradigm is preferable for dynamic environments rather than simple environments
* Reduced time efficiency compared to block-structured languages

===Summary of important differences===
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"
|-
! Difference
! Block Structured Languages
! Object-Oriented Languages
|-
| '''Problem approach'''
| Top-down approach is followed
| [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Bottom-up] approach is followed
|-
| '''Problem focus'''
| Focus is on the [http://en.wikipedia.org/wiki/Algorithm#Computer_algorithms algorithm] to solve the problem
| Focus is on getting the object design right
|-
| '''View of data and functions'''
| Views data and functions as separate entities
| Views data and functions as single entity
|-
| '''Cost of maintenance'''
| Maintenance is costly
| Maintenance is relatively cheaper
|-
| '''Software reuse'''
| Software reuse is not possible
| Software reuse is possible
|-
| '''Abstraction'''
| Function abstraction is used
| Data abstraction is used
|}

===Effectiveness and durability of object oriented languages over block structured languages ===

Although block structured languages were simpler and faster for smaller projects, when it comes to large commercial undertaking the manpower and tools required to maintain the code base is very prohibitive. It was very difficult to fix issues, add new features, and at the same time to make sure that the integrity of the code base is intact. Many projects were perpetually stagnant at 90% completion with issues coming up at the eleventh hour. All these problems led to the hastening of the move to object-oriented languages which showed it had the solutions to all the problems that block structured languages could not solve. The following four points are the most important reasons why object-oriented languages were more effective and durable that block structured languages:
* Maintenance - In block structured languages, especially in large projects, system maintenance became a challenge. Object oriented languages could counter this by providing clear demarcation between the objects and making it easier to work on individual aspects of the system without disturbing the other components.
* [http://en.wikipedia.org/wiki/Information_hiding Data hiding] - In block structured language system the data usually has global scope. Hence it is very difficult to monitor or supervise data access. This was solved by object-oriented languages by providing data encapsulation. The data and the corresponding attributes are put into a nice little package that was much easier to control and monitor.
* Code reuse - Object oriented languages are proponents of code reuse. Hence the code size could be reduced sufficiently enough when it comes to large projects to warrant a shift from block structured to object oriented languages.
* Feature additions - Object oriented languages provide a very cost effective and safe way to add new features to the existing system without causing the whole system to collapse. This feature is very important for large scale software vendors who provide various customizations.

===Applicability between paradigms===
Object-oriented languages have solved many problems that block structured languages introduced. But all is not lost with block structured languages. They boast some very important features that are needed in any programming language. The simplicity and readability of code in block structured languages are enviable features indeed. Because of this very simplicity we find that block structured languages are very efficient in terms of speed and performance. Such a language would also provide the flexibility in moving legacy block structured systems to the object oriented paradigm seamlessly. A language that can capture both sides of the argument would be a formidable entry into the growing list of programming languages. This explains why we see C++ emerging as one of the most popular object oriented languages. It has both the block structured features of C and the object-oriented concepts built into it, thereby making it a very versatile and efficient programming language.

==C/C++ Code Example==
{{Expand section}}
Below is a code example highlighting key differences between a block structured program and an object oriented program all in one source file.
<pre>// For block structure, leave the below line commented to compile in C
// For object oriented structure, uncomment the line to compile in C++
//#define USING_CPP

#ifndef USING_CPP

// C standard header files
#include <stdio.h>
#include <stdlib.h>

// Define the messages of each persona
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Define the function prototypes for delivering the different messages
char *getKingMessage();
char *getJesterMessage();
char *getPeonMessage();

// Main program entry point
int main()
{
// Go through and make each function call for...
// The King
printf("And now a message from the king: %s\n", getKingMessage());
printf("The King has spoken!\n\n");

// The Court Jester
printf("And now a message from the court jester: %s\n", getJesterMessage());
printf("Wocka wocka wocka!\n\n");

// A Peon
printf("And now a message from a peon: %s\n", getPeonMessage());
printf("... but don't mind me!\n\n");

// Wait for user input before exiting
system("pause");

return 0;
}

// Returns a string containing the text to be spoken by the king
char *getKingMessage()
{
return KING_MESSAGE;
}

// Returns a string containing the text to be spoken by the court jester
char *getJesterMessage()
{
return JESTER_MESSAGE;
}

// Returns a string containing the text to be spoken by all peons
char *getPeonMessage()
{
return PEON_MESSAGE;
}
#endif

#ifdef USING_CPP

// C++ standard headers
#include <cstdio>
#include <cstdlib>

// Define what each persona should say
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Keep all classes clearly separated from other sections of code
namespace Monarchy
{
// Define a basic class where a person has a label and something they want to say
class Person
{
private:
char *szMessage;
char *szLabel;

public:
// Allow a person to deliver their message
void DeliverMessage()
{
printf("A now a message from %s: %s\n", this->szLabel, this->szMessage);
}

// A person needs to be initialized with a label and a message
Person(char*label, char *msg)
{
this->szLabel = label;
this->szMessage = msg;
}
};

// The King is a person (and thus inherits from it)
class King : public Person
{
public:
// The king has the same label, but his message might change according to the political winds
King(char *msg) : Person("the king", msg)
{
}

// Here, the function is being overridden...
void DeliverMessage()
{
// .. but the base class's DeliverMessage is still being called, in addition to the tag line
Person::DeliverMessage();
printf("The King has spoken!\n\n");
}
};

// A peon is a person (and thus inherits from it)
class Peon : public Person
{
public:
// A peon has the same label but his message might change according to his or her attitude toward the king
Peon(char *msg) : Person("a peon", msg)
{
}

// Like above, deliver the message, but always provide a common tag line
void DeliverMessage()
{
Person::DeliverMessage();
printf("... but don't mind me!\n\n");
}
};

// A jester is a person (and thus inherits from it)
class Jester : public Person
{
public:
// A peon has the same label but his message might change if the king is sick of his jokes
Jester(char *msg) : Person("the court jester", msg)
{
}

// Might as well call him Fozzie ;)
void DeliverMessage()
{
Person::DeliverMessage();
printf("Wocka wocka wocka!\n\n");
}
};
}

// Main program entry point
int main()
{
// Initialize some monarchy objects
Monarchy::King TheKing(KING_MESSAGE);
Monarchy::Jester Borat(JESTER_MESSAGE);
Monarchy::Peon Bruno(PEON_MESSAGE);

// Let them deliver their messages
TheKing.DeliverMessage();
Borat.DeliverMessage();
Bruno.DeliverMessage();

// Wait for user input
system("pause");

return 0;
}
#endif</pre>

==See also==
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Functional_programming Functional programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Programming_paradigm Programming paradigm] at Wikipedia
* [http://en.wikipedia.org/wiki/Class-based_programming Class-based programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Prototype-based_programming Prototype-based programming] at Wikipedia

==References==
<references/>

==Further reading==
* Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. ''Head First Design Patterns''. Sebastopol, CA: O'Reilly, 2004. Print.
* Liberty, Jesse. ''Sams Teach Yourself C++ in 24 Hours''. Indianapolis, IN: Sams, 2002. Print.
* ''Microsoft Visual C++ Language Reference''. Redmond, WA: Microsoft, 1997. Print.
* Weiss, Mark Allen. ''Data Structures & Algorithm Analysis in Java''. Reading, MA: Addison-Wesley, 1999. Print.
* Mohamed Fayad, Mauri Laitinen. "TRANSITION TO OBJECT-ORIENTED SOFTWARE DEVELOPMENT."

==External links==
* [http://www.slideshare.net/spajus/object-oriented-programming-presentation-933801 Object Oriented Programming] at slide'''share'''
* [http://www.developer.com/java/other/article.php/3493761/The-Evolution-of-Object-Oriented-Languages.htm The Evolution of Object-Oriented Languages]
* [http://www.xp2003.org/the-history-of-oop.htm The History of OOP]
* [http://www.brighthub.com/internet/web-development/articles/82024.aspx Structured vs. Object-Oriented Programming: A Comparison]

CSC/ECE 517 Fall 2011/ch1 1e sa

2011-09-15T20:51:22Z

Sramach5: /* Effectiveness and durability of object oriented languages over block structured languages */

"'''Block vs Object-Oriented Programming Languages'''"

In computer science, computer programming languages exhibit variance in syntax and structure in order to effectively solve problems. Two of these variances can be seen between '''block structure''' and '''object-oriented structure'''. A programming language with block structure allows the programmer to group lines of code for convenient use throughout the rest of the program. Object-oriented structure meanwhile goes further to allow the programmer to associate data with its actions in a hierarchical manner. Object-oriented structure has many advantages which generally make it more effective and durable than block-structured languages, but object-oriented languages also benefit from the core ideas present in block structure programming.

==Block structure==
===Definition===
Block-structured programming languages are task-centric, high-level languages. Operations on data sets are emphasized in an attempt to logically organize program operation. The design and implementation involves breaking down the problem into discrete blocks or units which can be nested to any depth or not at all. Each block generally consists of a set of delimiters such as braces or keywords that separate them from other blocks. Each of these blocks contains a set of (optional) declarations and logic to solve a particular problem. Declarations inside of nested blocks introduces the concept of variable scope, which frees the programmer from having to worry about name collisions and other variable maintenance tasks.<ref>[http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] at Wikipedia</ref> A [[CSC/ECE_517_Fall_2011/ch1_1e_sa#C.2FC.2B.2B_Code_Example|code example]] of a block structured program is provided later in the article.

Overall, block-structured languages can be summarized as having the following features:
* Modular - Lines of code/functionality are grouped together
* Scoped - Variables are limited to the group of code they are declared in
* [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Top down] - Modules are created as necessary to meet the program's requirements
* Simple - It is generally simpler to "cobble together" modules of code that accomplish a simple, well-defined task.

===History===
Block-structured languages were first conceived in the 1950s with the advent of [http://en.wikipedia.org/wiki/ALGOL ALGOL], one of the first [http://en.wikipedia.org/wiki/Imperative_programming imperative programming languages]. An evolution of block structuring was created as the "GOTO" logic of programs became more and more difficult to understand and maintain. In 1968, famed computer scientist [http://en.wikipedia.org/wiki/Edsger_W._Dijkstra Edsger Dijkstra] wrote [http://dx.doi.org/10.1145%2F362929.362947 a letter] and [http://dx.doi.org/10.1145%2F355604.361591 follow-up article] on the ideas and motivation behind "[http://en.wikipedia.org/wiki/Structured_programming structured programming]," where the program exhibits “[http://en.wikipedia.org/wiki/Separation_of_concerns separation of concerns]," single point of entry but multiple points of exit, and ideas of data structures. It was Dijkstra’s and others’ which helped propel this basic idea of block structure programming into the mainstream.<ref>[http://en.wikipedia.org/wiki/Structured_programming Structured programming] at Wikipedia</ref>

===Programming languages===
Block-structured programming languages dominate the general purpose, imperative programming language arena. Indeed most programming languages in modern use enjoy some of the benefits of block structure with grouping of code and scope of variables. Indeed, ignoring their object-oriented aspects, all of [http://en.wikipedia.org/wiki/C_(programming_language) C], [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#], [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/PHP PHP] and [http://en.wikipedia.org/wiki/Visual_Basic Visual Basic] – for example – contain elements of block structure.

==Object-oriented structure==
===Definition===
Object-oriented languages have an important overall goal and foster major design principles.
====Description====
Object-oriented structured languages are data-centric, high-level languages. This is in contrast to block structure languages, which are task-centric. Compared to block-structure languages, logical organization of data and the methods associated with them are emphasized. It is a way of grouping data with executable code. These groups are called "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]." Objects utilize their data and interact with other objects such that a hierarchy is established (called "[http://en.wikipedia.org/wiki/Class_(computer_science) classes]" in popular languages). Toward this end and depending on the language, objects can be interrelated and defined so that their relationships can produce code that is well-organized, easy to read, and reusable.<ref name="oopref">[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] at Wikipedia</ref>

====Principles====
=====Encapsulation=====
Also referred to as "data hiding," [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation] shields the programmer from the implementation details of an object. These implementation details would include [http://en.wikipedia.org/wiki/Local_variable private variables], special [http://en.wikipedia.org/wiki/Library_(computing) libraries], and [http://en.wikipedia.org/wiki/Data_structure data structures] that the programmer does not need to know in order to utilize the functionality offered by the object.<ref>[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation (object-oriented programming)] at Wikipedia</ref>

=====Inheritance=====
[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] introduces the idea of objects sharing functionality in data or methods that are common. [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses Subclasses] can inherit data structures, functions, and attributes of their [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses superclasses] in order to create an object or [http://en.wikipedia.org/wiki/Class_hierarchy class hierarchy] that is effective in organizing data and methods in a logical manner.<ref>[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance (computer science)] at Wikipedia</ref>

=====Polymorphism=====
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] describes the idea of interfaces, where one data type can be defined that allows other dissimilar types to implement a common set of [http://en.wikipedia.org/wiki/Method_(computer_programming) methods] and [http://en.wikipedia.org/wiki/Field_(computer_science) fields]. This allows a high level of [http://en.wikipedia.org/wiki/Abstraction_(computer_science) abstraction] that allows programmers to write easily maintainable code.<ref>[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism in object-oriented programming] at Wikipedia</ref>

===History and transition===
Early forms of object oriented programming languages were created in the early 1960s with the creation of [http://en.wikipedia.org/wiki/Lisp_(programming_language) LISP] and an early form of ALGOL, with [http://en.wikipedia.org/wiki/Simula Simula 67] signaling the actual beginning of the object-oriented "revolution." The development of object-oriented languages progressed through other languages like [http://en.wikipedia.org/wiki/Simula Smalltalk] and the archetypal C++ to arrive at many of the object oriented languages we have today.<ref name="oopref"/> As processing capability has matured, so too have the capabilities of programming languages. More and more though, [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic programming languages] like [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] are being treated as "true" object-oriented languages because of their rapid prototpying ability and strong [http://en.wikipedia.org/wiki/Object-oriented_analysis_and_design object model].

===Programming languages===
A complete list of object oriented languages is outside the scope of this document, but some major examples are [http://en.wikipedia.org/wiki/Boo_(programming_language) Boo], C++, C#, [http://en.wikipedia.org/wiki/COBOL COBOL 2002], [http://en.wikipedia.org/wiki/F_Sharp_(programming_language) F#], [http://en.wikipedia.org/wiki/Fortran Fortran 2003], Java, [http://en.wikipedia.org/wiki/Matlab MATLAB], [http://en.wikipedia.org/wiki/Objective_c Objective-C], [http://en.wikipedia.org/wiki/PHP PHP 5], [http://en.wikipedia.org/wiki/Python_(programming_language) Python], Ruby, and Visual Basic.<ref>[http://en.wikipedia.org/wiki/List_of_object-oriented_programming_languages List of object-oriented programming languages] at Wikipedia</ref>

==Structure comparison==
===Advantages and disadvantages===
==== Block-structured languages ====
=====Advantages=====
* Simplicity
* Reduced coding and turnover time
* Dynamic lifetime of variables ([http://en.wikipedia.org/wiki/Scope_(computer_science) Scope]) provide efficient usage of memory since allocation and deletion occur at the entrance and exit of each block

=====Disadvantages=====
* Commercial projects are difficult to manage due to very large [http://en.wikipedia.org/wiki/Codebase codebase] sizes
* Reduced code [http://en.wikipedia.org/wiki/Reusability reusability]
* [http://en.wikipedia.org/wiki/Computer_security Security] concerns, espcially in the realm of [http://en.wikipedia.org/wiki/Array#In_computer_science arrays] and accessing [http://en.wikipedia.org/wiki/Value_(computer_science) elements] that are [http://en.wikipedia.org/wiki/Privilege_(computing) out of bounds]

====Object-Oriented languages====
=====Advantages=====
* The software objects model real world objects so program composition is well defined and structured
* Each object's definition and internal implementation is decoupled from other objects, making the system design inherently modular ([http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation])
* Adding new features becomes easier because of inheritance, allowing the new class to contain the new feature in addition to all old features from the inherited class
* [http://en.wikipedia.org/wiki/Debugging Debugging] is easier since each object's internal mechanisms are independent of each other, which helps in isolating errors and fixing them
* Enhanced code reusability

=====Disadvantages=====
* The complexity of object-oriented design becomes prohibitive when working on small projects
* Object-oriented programming paradigm is preferable for dynamic environments rather than simple environments
* Reduced time efficiency compared to block-structured languages

===Summary of important differences===
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"
|-
! Difference
! Block Structured Languages
! Object-Oriented Languages
|-
| '''Problem approach'''
| Top-down approach is followed
| [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Bottom-up] approach is followed
|-
| '''Problem focus'''
| Focus is on the [http://en.wikipedia.org/wiki/Algorithm#Computer_algorithms algorithm] to solve the problem
| Focus is on getting the object design right
|-
| '''View of data and functions'''
| Views data and functions as separate entities
| Views data and functions as single entity
|-
| '''Cost of maintenance'''
| Maintenance is costly
| Maintenance is relatively cheaper
|-
| '''Software reuse'''
| Software reuse is not possible
| Software reuse is possible
|-
| '''Abstraction'''
| Function abstraction is used
| Data abstraction is used
|}

===Effectiveness and durability of object oriented languages over block structured languages ===

Although block structured languages were simpler and faster for smaller projects, when it comes to large commercial undertaking the manpower and tools required to maintain the code base is very prohibitive. It was very difficult to fix issues, add new features, and at the same time to make sure that the integrity of the code base is intact. Many projects were perpetually stagnant at 90% completion with issues coming up at the eleventh hour. All these problems led to the hastening of the move to object-oriented languages which showed it had the solutions to all the problems that block structured languages could not solve. The following four points are the most important reasons why object-oriented languages were more effective and durable that block structured languages:
* Maintenance - In block structured languages, especially in large projects, system maintenance became a challenge. Object oriented languages could counter this by providing clear demarcation between the objects and making it easier to work on individual aspects of the system without disturbing the other components.
* [http://en.wikipedia.org/wiki/Information_hiding Data hiding] - In block structured language system the data usually has global scope. Hence it is very difficult to monitor or supervise data access. This was solved by object-oriented languages by providing data encapsulation. The data and the corresponding attributes are put into a nice little package that was much easier to control and monitor.
* Code reuse - Object oriented languages are proponents of code reuse. Hence the code size could be reduced sufficiently enough when it comes to large projects to warrant a shift from block structured to object oriented languages.
* Feature additions - Object oriented languages provide a very cost effective and safe way to add new features to the existing system without causing the whole system to collapse. This feature is very important for large scale software vendors who provide various customizations.

===Applicability between paradigms===
Object-oriented languages have solved many problems that block structured languages introduced. But all is not lost with block structured languages. They boast some very important features that are needed in any programming language. The simplicity and readability of code in block structured languages are enviable features indeed. Because of this very simplicity we find that block structured languages are very efficient in terms of speed and performance. Such a language would also provide the flexibility in moving legacy block structured systems to the object oriented paradigm seamlessly. A language that can capture both sides of the argument would be a formidable entry into the growing list of programming languages. This explains why we see C++ emerging as one of the most popular object oriented languages. It has both the block structured features of C and the object-oriented concepts built into it, thereby making it a very versatile and efficient programming language.

==C/C++ Code Example==
{{Expand section}}
Below is a code example highlighting key differences between a block structured program and an object oriented program all in one source file.
<pre>// For block structure, leave the below line commented to compile in C
// For object oriented structure, uncomment the line to compile in C++
//#define USING_CPP

#ifndef USING_CPP

// C standard header files
#include <stdio.h>
#include <stdlib.h>

// Define the messages of each persona
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Define the function prototypes for delivering the different messages
char *getKingMessage();
char *getJesterMessage();
char *getPeonMessage();

// Main program entry point
int main()
{
// Go through and make each function call for...
// The King
printf("And now a message from the king: %s\n", getKingMessage());
printf("The King has spoken!\n\n");

// The Court Jester
printf("And now a message from the court jester: %s\n", getJesterMessage());
printf("Wocka wocka wocka!\n\n");

// A Peon
printf("And now a message from a peon: %s\n", getPeonMessage());
printf("... but don't mind me!\n\n");

// Wait for user input before exiting
system("pause");

return 0;
}

// Returns a string containing the text to be spoken by the king
char *getKingMessage()
{
return KING_MESSAGE;
}

// Returns a string containing the text to be spoken by the court jester
char *getJesterMessage()
{
return JESTER_MESSAGE;
}

// Returns a string containing the text to be spoken by all peons
char *getPeonMessage()
{
return PEON_MESSAGE;
}
#endif

#ifdef USING_CPP

// C++ standard headers
#include <cstdio>
#include <cstdlib>

// Define what each persona should say
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Keep all classes clearly separated from other sections of code
namespace Monarchy
{
// Define a basic class where a person has a label and something they want to say
class Person
{
private:
char *szMessage;
char *szLabel;

public:
// Allow a person to deliver their message
void DeliverMessage()
{
printf("A now a message from %s: %s\n", this->szLabel, this->szMessage);
}

// A person needs to be initialized with a label and a message
Person(char*label, char *msg)
{
this->szLabel = label;
this->szMessage = msg;
}
};

// The King is a person (and thus inherits from it)
class King : public Person
{
public:
// The king has the same label, but his message might change according to the political winds
King(char *msg) : Person("the king", msg)
{
}

// Here, the function is being overridden...
void DeliverMessage()
{
// .. but the base class's DeliverMessage is still being called, in addition to the tag line
Person::DeliverMessage();
printf("The King has spoken!\n\n");
}
};

// A peon is a person (and thus inherits from it)
class Peon : public Person
{
public:
// A peon has the same label but his message might change according to his or her attitude toward the king
Peon(char *msg) : Person("a peon", msg)
{
}

// Like above, deliver the message, but always provide a common tag line
void DeliverMessage()
{
Person::DeliverMessage();
printf("... but don't mind me!\n\n");
}
};

// A jester is a person (and thus inherits from it)
class Jester : public Person
{
public:
// A peon has the same label but his message might change if the king is sick of his jokes
Jester(char *msg) : Person("the court jester", msg)
{
}

// Might as well call him Fozzie ;)
void DeliverMessage()
{
Person::DeliverMessage();
printf("Wocka wocka wocka!\n\n");
}
};
}

// Main program entry point
int main()
{
// Initialize some monarchy objects
Monarchy::King TheKing(KING_MESSAGE);
Monarchy::Jester Borat(JESTER_MESSAGE);
Monarchy::Peon Bruno(PEON_MESSAGE);

// Let them deliver their messages
TheKing.DeliverMessage();
Borat.DeliverMessage();
Bruno.DeliverMessage();

// Wait for user input
system("pause");

return 0;
}
#endif</pre>

==See also==
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Functional_programming Functional programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Programming_paradigm Programming paradigm] at Wikipedia
* [http://en.wikipedia.org/wiki/Class-based_programming Class-based programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Prototype-based_programming Prototype-based programming] at Wikipedia

==References==
<references/>

==Further reading==
* Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. ''Head First Design Patterns''. Sebastopol, CA: O'Reilly, 2004. Print.
* Liberty, Jesse. ''Sams Teach Yourself C++ in 24 Hours''. Indianapolis, IN: Sams, 2002. Print.
* ''Microsoft Visual C++ Language Reference''. Redmond, WA: Microsoft, 1997. Print.
* Weiss, Mark Allen. ''Data Structures & Algorithm Analysis in Java''. Reading, MA: Addison-Wesley, 1999. Print.
* Mohamed Fayad, Mauri Laitinen. "TRANSITION TO OBJECT-ORIENTED SOFTWARE DEVELOPMENT."

==External links==
* [http://www.slideshare.net/spajus/object-oriented-programming-presentation-933801 Object Oriented Programming] at slide'''share'''
* [http://www.developer.com/java/other/article.php/3493761/The-Evolution-of-Object-Oriented-Languages.htm The Evolution of Object-Oriented Languages]
* [http://www.xp2003.org/the-history-of-oop.htm The History of OOP]
* [http://www.brighthub.com/internet/web-development/articles/82024.aspx Structured vs. Object-Oriented Programming: A Comparison]

CSC/ECE 517 Fall 2011/ch1 1e sa

2011-09-15T20:11:21Z

Sramach5: /* Advantages */

"'''Block vs Object-Oriented Programming Languages'''"

In computer science, computer programming languages exhibit variance in syntax and structure in order to effectively solve problems. Two of these variances can be seen between '''block structure''' and '''object-oriented structure'''. A programming language with block structure allows the programmer to group lines of code for convenient use throughout the rest of the program. Object-oriented structure meanwhile goes further to allow the programmer to associate data with its actions in a hierarchical manner. Object-oriented structure has many advantages which generally make it more effective and durable than block-structured languages, but object-oriented languages also benefit from the core ideas present in block structure programming.

==Block structure==
===Definition===
Block-structured programming languages are task-centric, high-level languages. Operations on data sets are emphasized in an attempt to logically organize program operation. The design and implementation involves breaking down the problem into discrete blocks or units which can be nested to any depth or not at all. Each block generally consists of a set of delimiters such as braces or keywords that separate them from other blocks. Each of these blocks contains a set of (optional) declarations and logic to solve a particular problem. Declarations inside of nested blocks introduces the concept of variable scope, which frees the programmer from having to worry about name collisions and other variable maintenance tasks.<ref>[http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] at Wikipedia</ref> A [[CSC/ECE_517_Fall_2011/ch1_1e_sa#C.2FC.2B.2B_Code_Example|code example]] of a block structured program is provided later in the article.

Overall, block-structured languages can be summarized as having the following features:
* Modular - Lines of code/functionality are grouped together
* Scoped - Variables are limited to the group of code they are declared in
* [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Top down] - Modules are created as necessary to meet the program's requirements
* Simple - It is generally simpler to "cobble together" modules of code that accomplish a simple, well-defined task.

===History===
Block-structured languages were first conceived in the 1950s with the advent of [http://en.wikipedia.org/wiki/ALGOL ALGOL], one of the first [http://en.wikipedia.org/wiki/Imperative_programming imperative programming languages]. An evolution of block structuring was created as the "GOTO" logic of programs became more and more difficult to understand and maintain. In 1968, famed computer scientist [http://en.wikipedia.org/wiki/Edsger_W._Dijkstra Edsger Dijkstra] wrote [http://dx.doi.org/10.1145%2F362929.362947 a letter] and [http://dx.doi.org/10.1145%2F355604.361591 follow-up article] on the ideas and motivation behind "[http://en.wikipedia.org/wiki/Structured_programming structured programming]," where the program exhibits “[http://en.wikipedia.org/wiki/Separation_of_concerns separation of concerns]," single point of entry but multiple points of exit, and ideas of data structures. It was Dijkstra’s and others’ which helped propel this basic idea of block structure programming into the mainstream.<ref>[http://en.wikipedia.org/wiki/Structured_programming Structured programming] at Wikipedia</ref>

===Programming languages===
Block-structured programming languages dominate the general purpose, imperative programming language arena. Indeed most programming languages in modern use enjoy some of the benefits of block structure with grouping of code and scope of variables. Indeed, ignoring their object-oriented aspects, all of [http://en.wikipedia.org/wiki/C_(programming_language) C], [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#], [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/PHP PHP] and [http://en.wikipedia.org/wiki/Visual_Basic Visual Basic] – for example – contain elements of block structure.

==Object-oriented structure==
===Definition===
Object-oriented languages have an important overall goal and foster major design principles.
====Description====
Object-oriented structured languages are data-centric, high-level languages. This is in contrast to block structure languages, which are task-centric. Compared to block-structure languages, logical organization of data and the methods associated with them are emphasized. It is a way of grouping data with executable code. These groups are called "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]." Objects utilize their data and interact with other objects such that a hierarchy is established (called "[http://en.wikipedia.org/wiki/Class_(computer_science) classes]" in popular languages). Toward this end and depending on the language, objects can be interrelated and defined so that their relationships can produce code that is well-organized, easy to read, and reusable.<ref name="oopref">[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] at Wikipedia</ref>

====Principles====
=====Encapsulation=====
Also referred to as "data hiding," [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation] shields the programmer from the implementation details of an object. These implementation details would include [http://en.wikipedia.org/wiki/Local_variable private variables], special [http://en.wikipedia.org/wiki/Library_(computing) libraries], and [http://en.wikipedia.org/wiki/Data_structure data structures] that the programmer does not need to know in order to utilize the functionality offered by the object.<ref>[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation (object-oriented programming)] at Wikipedia</ref>

=====Inheritance=====
[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] introduces the idea of objects sharing functionality in data or methods that are common. [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses Subclasses] can inherit data structures, functions, and attributes of their [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses superclasses] in order to create an object or [http://en.wikipedia.org/wiki/Class_hierarchy class hierarchy] that is effective in organizing data and methods in a logical manner.<ref>[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance (computer science)] at Wikipedia</ref>

=====Polymorphism=====
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] describes the idea of interfaces, where one data type can be defined that allows other dissimilar types to implement a common set of [http://en.wikipedia.org/wiki/Method_(computer_programming) methods] and [http://en.wikipedia.org/wiki/Field_(computer_science) fields]. This allows a high level of [http://en.wikipedia.org/wiki/Abstraction_(computer_science) abstraction] that allows programmers to write easily maintainable code.<ref>[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism in object-oriented programming] at Wikipedia</ref>

===History and transition===
Early forms of object oriented programming languages were created in the early 1960s with the creation of [http://en.wikipedia.org/wiki/Lisp_(programming_language) LISP] and an early form of ALGOL, with [http://en.wikipedia.org/wiki/Simula Simula 67] signaling the actual beginning of the object-oriented "revolution." The development of object-oriented languages progressed through other languages like [http://en.wikipedia.org/wiki/Simula Smalltalk] and the archetypal C++ to arrive at many of the object oriented languages we have today.<ref name="oopref"/> As processing capability has matured, so too have the capabilities of programming languages. More and more though, [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic programming languages] like [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] are being treated as "true" object-oriented languages because of their rapid prototpying ability and strong [http://en.wikipedia.org/wiki/Object-oriented_analysis_and_design object model].

===Programming languages===
A complete list of object oriented languages is outside the scope of this document, but some major examples are [http://en.wikipedia.org/wiki/Boo_(programming_language) Boo], C++, C#, [http://en.wikipedia.org/wiki/COBOL COBOL 2002], [http://en.wikipedia.org/wiki/F_Sharp_(programming_language) F#], [http://en.wikipedia.org/wiki/Fortran Fortran 2003], Java, [http://en.wikipedia.org/wiki/Matlab MATLAB], [http://en.wikipedia.org/wiki/Objective_c Objective-C], [http://en.wikipedia.org/wiki/PHP PHP 5], [http://en.wikipedia.org/wiki/Python_(programming_language) Python], Ruby, and Visual Basic.<ref>[http://en.wikipedia.org/wiki/List_of_object-oriented_programming_languages List of object-oriented programming languages] at Wikipedia</ref>

==Structure comparison==
===Advantages and disadvantages===
==== Block-structured languages ====
=====Advantages=====
* Simplicity
* Reduced coding and turnover time
* Dynamic lifetime of variables ([http://en.wikipedia.org/wiki/Scope_(computer_science) Scope]) provide efficient usage of memory since allocation and deletion occur at the entrance and exit of each block

=====Disadvantages=====
* Commercial projects are difficult to manage due to very large [http://en.wikipedia.org/wiki/Codebase codebase] sizes
* Reduced code [http://en.wikipedia.org/wiki/Reusability reusability]
* [http://en.wikipedia.org/wiki/Computer_security Security] concerns, espcially in the realm of [http://en.wikipedia.org/wiki/Array#In_computer_science arrays] and accessing [http://en.wikipedia.org/wiki/Value_(computer_science) elements] that are [http://en.wikipedia.org/wiki/Privilege_(computing) out of bounds]

====Object-Oriented languages====
=====Advantages=====
* The software objects model real world objects so program composition is well defined and structured
* Each object's definition and internal implementation is decoupled from other objects, making the system design inherently modular ([http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation])
* Adding new features becomes easier because of inheritance, allowing the new class to contain the new feature in addition to all old features from the inherited class
* [http://en.wikipedia.org/wiki/Debugging Debugging] is easier since each object's internal mechanisms are independent of each other, which helps in isolating errors and fixing them
* Enhanced code reusability

=====Disadvantages=====
* The complexity of object-oriented design becomes prohibitive when working on small projects
* Object-oriented programming paradigm is preferable for dynamic environments rather than simple environments
* Reduced time efficiency compared to block-structured languages

===Summary of important differences===
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"
|-
! Difference
! Block Structured Languages
! Object-Oriented Languages
|-
| '''Problem approach'''
| Top-down approach is followed
| [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Bottom-up] approach is followed
|-
| '''Problem focus'''
| Focus is on the [http://en.wikipedia.org/wiki/Algorithm#Computer_algorithms algorithm] to solve the problem
| Focus is on getting the object design right
|-
| '''View of data and functions'''
| Views data and functions as separate entities
| Views data and functions as single entity
|-
| '''Cost of maintenance'''
| Maintenance is costly
| Maintenance is relatively cheaper
|-
| '''Software reuse'''
| Software reuse is not possible
| Software reuse is possible
|-
| '''Abstraction'''
| Function abstraction is used
| Data abstraction is used
|}

===Effectiveness and durability of object oriented languages over block structured languages ===

Although block structured languages were simpler and faster for smaller projects, when it comes to large commercial undertaking the manpower and tools required to maintain the code base is very prohibitive. It was very difficult to fix issues, add new features, and at the same time to make sure that the integrity of the code base is intact. Many projects were perpetually stagnant at 90% completion with issues coming up at the eleventh hour. All these problems led to the hastening of the move to object-oriented languages which showed it had the solutions to all the problems that block structured languages could not solve. The following four points are the most important reasons why object-oriented languages were more effective and durable that block structured languages:
* Maintenance - In block structured languages, especially in large projects, system maintenance became a challenge. Object oriented languages could counter this by providing clear demarcation between the objects and making it easier to work on individual aspects of the system without disturbing the other components.
* Data hiding - In block structured language system the data usually has global scope. Hence it is very difficult to monitor or supervise data access. This was solved by object-oriented languages by providing data encapsulation. The data and the corresponding attributes are put into a nice little package that was much easier to control and monitor.
* Code reuse - Object oriented languages are proponents of code reuse. Hence the code size could be reduced sufficiently enough when it comes to large projects to warrant a shift from block structured to object oriented languages.
* Feature additions - Object oriented languages provide a very cost effective and safe way to add new features to the existing system without causing the whole system to collapse. This feature is very important for large scale software vendors who provide various customizations.

===Applicability between paradigms===
Object-oriented languages have solved many problems that block structured languages introduced. But all is not lost with block structured languages. They boast some very important features that are needed in any programming language. The simplicity and readability of code in block structured languages are enviable features indeed. Because of this very simplicity we find that block structured languages are very efficient in terms of speed and performance. Such a language would also provide the flexibility in moving legacy block structured systems to the object oriented paradigm seamlessly. A language that can capture both sides of the argument would be a formidable entry into the growing list of programming languages. This explains why we see C++ emerging as one of the most popular object oriented languages. It has both the block structured features of C and the object-oriented concepts built into it, thereby making it a very versatile and efficient programming language.

==C/C++ Code Example==
{{Expand section}}
Below is a code example highlighting key differences between a block structured program and an object oriented program all in one source file.
<pre>// For block structure, leave the below line commented to compile in C
// For object oriented structure, uncomment the line to compile in C++
//#define USING_CPP

#ifndef USING_CPP

// C standard header files
#include <stdio.h>
#include <stdlib.h>

// Define the messages of each persona
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Define the function prototypes for delivering the different messages
char *getKingMessage();
char *getJesterMessage();
char *getPeonMessage();

// Main program entry point
int main()
{
// Go through and make each function call for...
// The King
printf("And now a message from the king: %s\n", getKingMessage());
printf("The King has spoken!\n\n");

// The Court Jester
printf("And now a message from the court jester: %s\n", getJesterMessage());
printf("Wocka wocka wocka!\n\n");

// A Peon
printf("And now a message from a peon: %s\n", getPeonMessage());
printf("... but don't mind me!\n\n");

// Wait for user input before exiting
system("pause");

return 0;
}

// Returns a string containing the text to be spoken by the king
char *getKingMessage()
{
return KING_MESSAGE;
}

// Returns a string containing the text to be spoken by the court jester
char *getJesterMessage()
{
return JESTER_MESSAGE;
}

// Returns a string containing the text to be spoken by all peons
char *getPeonMessage()
{
return PEON_MESSAGE;
}
#endif

#ifdef USING_CPP

// C++ standard headers
#include <cstdio>
#include <cstdlib>

// Define what each persona should say
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Keep all classes clearly separated from other sections of code
namespace Monarchy
{
// Define a basic class where a person has a label and something they want to say
class Person
{
private:
char *szMessage;
char *szLabel;

public:
// Allow a person to deliver their message
void DeliverMessage()
{
printf("A now a message from %s: %s\n", this->szLabel, this->szMessage);
}

// A person needs to be initialized with a label and a message
Person(char*label, char *msg)
{
this->szLabel = label;
this->szMessage = msg;
}
};

// The King is a person (and thus inherits from it)
class King : public Person
{
public:
// The king has the same label, but his message might change according to the political winds
King(char *msg) : Person("the king", msg)
{
}

// Here, the function is being overridden...
void DeliverMessage()
{
// .. but the base class's DeliverMessage is still being called, in addition to the tag line
Person::DeliverMessage();
printf("The King has spoken!\n\n");
}
};

// A peon is a person (and thus inherits from it)
class Peon : public Person
{
public:
// A peon has the same label but his message might change according to his or her attitude toward the king
Peon(char *msg) : Person("a peon", msg)
{
}

// Like above, deliver the message, but always provide a common tag line
void DeliverMessage()
{
Person::DeliverMessage();
printf("... but don't mind me!\n\n");
}
};

// A jester is a person (and thus inherits from it)
class Jester : public Person
{
public:
// A peon has the same label but his message might change if the king is sick of his jokes
Jester(char *msg) : Person("the court jester", msg)
{
}

// Might as well call him Fozzie ;)
void DeliverMessage()
{
Person::DeliverMessage();
printf("Wocka wocka wocka!\n\n");
}
};
}

// Main program entry point
int main()
{
// Initialize some monarchy objects
Monarchy::King TheKing(KING_MESSAGE);
Monarchy::Jester Borat(JESTER_MESSAGE);
Monarchy::Peon Bruno(PEON_MESSAGE);

// Let them deliver their messages
TheKing.DeliverMessage();
Borat.DeliverMessage();
Bruno.DeliverMessage();

// Wait for user input
system("pause");

return 0;
}
#endif</pre>

==See also==
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Functional_programming Functional programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Programming_paradigm Programming paradigm] at Wikipedia
* [http://en.wikipedia.org/wiki/Class-based_programming Class-based programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Prototype-based_programming Prototype-based programming] at Wikipedia

==References==
<references/>

==Further reading==
* Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. ''Head First Design Patterns''. Sebastopol, CA: O'Reilly, 2004. Print.
* Liberty, Jesse. ''Sams Teach Yourself C++ in 24 Hours''. Indianapolis, IN: Sams, 2002. Print.
* ''Microsoft Visual C++ Language Reference''. Redmond, WA: Microsoft, 1997. Print.
* Weiss, Mark Allen. ''Data Structures & Algorithm Analysis in Java''. Reading, MA: Addison-Wesley, 1999. Print.
* Mohamed Fayad, Mauri Laitinen. "TRANSITION TO OBJECT-ORIENTED SOFTWARE DEVELOPMENT."

==External links==
* [http://www.slideshare.net/spajus/object-oriented-programming-presentation-933801 Object Oriented Programming] at slide'''share'''
* [http://www.developer.com/java/other/article.php/3493761/The-Evolution-of-Object-Oriented-Languages.htm The Evolution of Object-Oriented Languages]
* [http://www.xp2003.org/the-history-of-oop.htm The History of OOP]
* [http://www.brighthub.com/internet/web-development/articles/82024.aspx Structured vs. Object-Oriented Programming: A Comparison]

CSC/ECE 517 Fall 2011/ch1 1e sa

2011-09-15T20:10:29Z

Sramach5: /* Disadvantages */

"'''Block vs Object-Oriented Programming Languages'''"

In computer science, computer programming languages exhibit variance in syntax and structure in order to effectively solve problems. Two of these variances can be seen between '''block structure''' and '''object-oriented structure'''. A programming language with block structure allows the programmer to group lines of code for convenient use throughout the rest of the program. Object-oriented structure meanwhile goes further to allow the programmer to associate data with its actions in a hierarchical manner. Object-oriented structure has many advantages which generally make it more effective and durable than block-structured languages, but object-oriented languages also benefit from the core ideas present in block structure programming.

==Block structure==
===Definition===
Block-structured programming languages are task-centric, high-level languages. Operations on data sets are emphasized in an attempt to logically organize program operation. The design and implementation involves breaking down the problem into discrete blocks or units which can be nested to any depth or not at all. Each block generally consists of a set of delimiters such as braces or keywords that separate them from other blocks. Each of these blocks contains a set of (optional) declarations and logic to solve a particular problem. Declarations inside of nested blocks introduces the concept of variable scope, which frees the programmer from having to worry about name collisions and other variable maintenance tasks.<ref>[http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] at Wikipedia</ref> A [[CSC/ECE_517_Fall_2011/ch1_1e_sa#C.2FC.2B.2B_Code_Example|code example]] of a block structured program is provided later in the article.

Overall, block-structured languages can be summarized as having the following features:
* Modular - Lines of code/functionality are grouped together
* Scoped - Variables are limited to the group of code they are declared in
* [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Top down] - Modules are created as necessary to meet the program's requirements
* Simple - It is generally simpler to "cobble together" modules of code that accomplish a simple, well-defined task.

===History===
Block-structured languages were first conceived in the 1950s with the advent of [http://en.wikipedia.org/wiki/ALGOL ALGOL], one of the first [http://en.wikipedia.org/wiki/Imperative_programming imperative programming languages]. An evolution of block structuring was created as the "GOTO" logic of programs became more and more difficult to understand and maintain. In 1968, famed computer scientist [http://en.wikipedia.org/wiki/Edsger_W._Dijkstra Edsger Dijkstra] wrote [http://dx.doi.org/10.1145%2F362929.362947 a letter] and [http://dx.doi.org/10.1145%2F355604.361591 follow-up article] on the ideas and motivation behind "[http://en.wikipedia.org/wiki/Structured_programming structured programming]," where the program exhibits “[http://en.wikipedia.org/wiki/Separation_of_concerns separation of concerns]," single point of entry but multiple points of exit, and ideas of data structures. It was Dijkstra’s and others’ which helped propel this basic idea of block structure programming into the mainstream.<ref>[http://en.wikipedia.org/wiki/Structured_programming Structured programming] at Wikipedia</ref>

===Programming languages===
Block-structured programming languages dominate the general purpose, imperative programming language arena. Indeed most programming languages in modern use enjoy some of the benefits of block structure with grouping of code and scope of variables. Indeed, ignoring their object-oriented aspects, all of [http://en.wikipedia.org/wiki/C_(programming_language) C], [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#], [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/PHP PHP] and [http://en.wikipedia.org/wiki/Visual_Basic Visual Basic] – for example – contain elements of block structure.

==Object-oriented structure==
===Definition===
Object-oriented languages have an important overall goal and foster major design principles.
====Description====
Object-oriented structured languages are data-centric, high-level languages. This is in contrast to block structure languages, which are task-centric. Compared to block-structure languages, logical organization of data and the methods associated with them are emphasized. It is a way of grouping data with executable code. These groups are called "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]." Objects utilize their data and interact with other objects such that a hierarchy is established (called "[http://en.wikipedia.org/wiki/Class_(computer_science) classes]" in popular languages). Toward this end and depending on the language, objects can be interrelated and defined so that their relationships can produce code that is well-organized, easy to read, and reusable.<ref name="oopref">[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] at Wikipedia</ref>

====Principles====
=====Encapsulation=====
Also referred to as "data hiding," [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation] shields the programmer from the implementation details of an object. These implementation details would include [http://en.wikipedia.org/wiki/Local_variable private variables], special [http://en.wikipedia.org/wiki/Library_(computing) libraries], and [http://en.wikipedia.org/wiki/Data_structure data structures] that the programmer does not need to know in order to utilize the functionality offered by the object.<ref>[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation (object-oriented programming)] at Wikipedia</ref>

=====Inheritance=====
[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] introduces the idea of objects sharing functionality in data or methods that are common. [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses Subclasses] can inherit data structures, functions, and attributes of their [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses superclasses] in order to create an object or [http://en.wikipedia.org/wiki/Class_hierarchy class hierarchy] that is effective in organizing data and methods in a logical manner.<ref>[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance (computer science)] at Wikipedia</ref>

=====Polymorphism=====
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] describes the idea of interfaces, where one data type can be defined that allows other dissimilar types to implement a common set of [http://en.wikipedia.org/wiki/Method_(computer_programming) methods] and [http://en.wikipedia.org/wiki/Field_(computer_science) fields]. This allows a high level of [http://en.wikipedia.org/wiki/Abstraction_(computer_science) abstraction] that allows programmers to write easily maintainable code.<ref>[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism in object-oriented programming] at Wikipedia</ref>

===History and transition===
Early forms of object oriented programming languages were created in the early 1960s with the creation of [http://en.wikipedia.org/wiki/Lisp_(programming_language) LISP] and an early form of ALGOL, with [http://en.wikipedia.org/wiki/Simula Simula 67] signaling the actual beginning of the object-oriented "revolution." The development of object-oriented languages progressed through other languages like [http://en.wikipedia.org/wiki/Simula Smalltalk] and the archetypal C++ to arrive at many of the object oriented languages we have today.<ref name="oopref"/> As processing capability has matured, so too have the capabilities of programming languages. More and more though, [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic programming languages] like [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] are being treated as "true" object-oriented languages because of their rapid prototpying ability and strong [http://en.wikipedia.org/wiki/Object-oriented_analysis_and_design object model].

===Programming languages===
A complete list of object oriented languages is outside the scope of this document, but some major examples are [http://en.wikipedia.org/wiki/Boo_(programming_language) Boo], C++, C#, [http://en.wikipedia.org/wiki/COBOL COBOL 2002], [http://en.wikipedia.org/wiki/F_Sharp_(programming_language) F#], [http://en.wikipedia.org/wiki/Fortran Fortran 2003], Java, [http://en.wikipedia.org/wiki/Matlab MATLAB], [http://en.wikipedia.org/wiki/Objective_c Objective-C], [http://en.wikipedia.org/wiki/PHP PHP 5], [http://en.wikipedia.org/wiki/Python_(programming_language) Python], Ruby, and Visual Basic.<ref>[http://en.wikipedia.org/wiki/List_of_object-oriented_programming_languages List of object-oriented programming languages] at Wikipedia</ref>

==Structure comparison==
===Advantages and disadvantages===
==== Block-structured languages ====
=====Advantages=====
* Simplicity
* Reduced coding and turnover time
* Dynamic lifetime of variables ([http://en.wikipedia.org/wiki/Scope_(computer_science) Scope]) provide efficient usage of memory since allocation and deletion occur at the entrance and exit of each block

=====Disadvantages=====
* Commercial projects are difficult to manage due to very large [http://en.wikipedia.org/wiki/Codebase codebase] sizes
* Reduced code [http://en.wikipedia.org/wiki/Reusability reusability]
* [http://en.wikipedia.org/wiki/Computer_security Security] concerns, espcially in the realm of [http://en.wikipedia.org/wiki/Array#In_computer_science arrays] and accessing [http://en.wikipedia.org/wiki/Value_(computer_science) elements] that are [http://en.wikipedia.org/wiki/Privilege_(computing) out of bounds]

====Object-Oriented languages====
=====Advantages=====
* The software objects model real world objects so program composition is well defined and structured
* Each object's definition and internal implementation is decoupled from other objects, making the system design inherently modular ([http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation])
* Adding new features becomes easier because of inheritance, allowing the new class to contain the new feature in addition to all old features from the inherited class
* Debugging is easier since each object's internal mechanisms are independent of each other, which helps in isolating errors and fixing them
* Enhanced code reusability

=====Disadvantages=====
* The complexity of object-oriented design becomes prohibitive when working on small projects
* Object-oriented programming paradigm is preferable for dynamic environments rather than simple environments
* Reduced time efficiency compared to block-structured languages

===Summary of important differences===
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"
|-
! Difference
! Block Structured Languages
! Object-Oriented Languages
|-
| '''Problem approach'''
| Top-down approach is followed
| [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Bottom-up] approach is followed
|-
| '''Problem focus'''
| Focus is on the [http://en.wikipedia.org/wiki/Algorithm#Computer_algorithms algorithm] to solve the problem
| Focus is on getting the object design right
|-
| '''View of data and functions'''
| Views data and functions as separate entities
| Views data and functions as single entity
|-
| '''Cost of maintenance'''
| Maintenance is costly
| Maintenance is relatively cheaper
|-
| '''Software reuse'''
| Software reuse is not possible
| Software reuse is possible
|-
| '''Abstraction'''
| Function abstraction is used
| Data abstraction is used
|}

===Effectiveness and durability of object oriented languages over block structured languages ===

Although block structured languages were simpler and faster for smaller projects, when it comes to large commercial undertaking the manpower and tools required to maintain the code base is very prohibitive. It was very difficult to fix issues, add new features, and at the same time to make sure that the integrity of the code base is intact. Many projects were perpetually stagnant at 90% completion with issues coming up at the eleventh hour. All these problems led to the hastening of the move to object-oriented languages which showed it had the solutions to all the problems that block structured languages could not solve. The following four points are the most important reasons why object-oriented languages were more effective and durable that block structured languages:
* Maintenance - In block structured languages, especially in large projects, system maintenance became a challenge. Object oriented languages could counter this by providing clear demarcation between the objects and making it easier to work on individual aspects of the system without disturbing the other components.
* Data hiding - In block structured language system the data usually has global scope. Hence it is very difficult to monitor or supervise data access. This was solved by object-oriented languages by providing data encapsulation. The data and the corresponding attributes are put into a nice little package that was much easier to control and monitor.
* Code reuse - Object oriented languages are proponents of code reuse. Hence the code size could be reduced sufficiently enough when it comes to large projects to warrant a shift from block structured to object oriented languages.
* Feature additions - Object oriented languages provide a very cost effective and safe way to add new features to the existing system without causing the whole system to collapse. This feature is very important for large scale software vendors who provide various customizations.

===Applicability between paradigms===
Object-oriented languages have solved many problems that block structured languages introduced. But all is not lost with block structured languages. They boast some very important features that are needed in any programming language. The simplicity and readability of code in block structured languages are enviable features indeed. Because of this very simplicity we find that block structured languages are very efficient in terms of speed and performance. Such a language would also provide the flexibility in moving legacy block structured systems to the object oriented paradigm seamlessly. A language that can capture both sides of the argument would be a formidable entry into the growing list of programming languages. This explains why we see C++ emerging as one of the most popular object oriented languages. It has both the block structured features of C and the object-oriented concepts built into it, thereby making it a very versatile and efficient programming language.

==C/C++ Code Example==
{{Expand section}}
Below is a code example highlighting key differences between a block structured program and an object oriented program all in one source file.
<pre>// For block structure, leave the below line commented to compile in C
// For object oriented structure, uncomment the line to compile in C++
//#define USING_CPP

#ifndef USING_CPP

// C standard header files
#include <stdio.h>
#include <stdlib.h>

// Define the messages of each persona
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Define the function prototypes for delivering the different messages
char *getKingMessage();
char *getJesterMessage();
char *getPeonMessage();

// Main program entry point
int main()
{
// Go through and make each function call for...
// The King
printf("And now a message from the king: %s\n", getKingMessage());
printf("The King has spoken!\n\n");

// The Court Jester
printf("And now a message from the court jester: %s\n", getJesterMessage());
printf("Wocka wocka wocka!\n\n");

// A Peon
printf("And now a message from a peon: %s\n", getPeonMessage());
printf("... but don't mind me!\n\n");

// Wait for user input before exiting
system("pause");

return 0;
}

// Returns a string containing the text to be spoken by the king
char *getKingMessage()
{
return KING_MESSAGE;
}

// Returns a string containing the text to be spoken by the court jester
char *getJesterMessage()
{
return JESTER_MESSAGE;
}

// Returns a string containing the text to be spoken by all peons
char *getPeonMessage()
{
return PEON_MESSAGE;
}
#endif

#ifdef USING_CPP

// C++ standard headers
#include <cstdio>
#include <cstdlib>

// Define what each persona should say
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Keep all classes clearly separated from other sections of code
namespace Monarchy
{
// Define a basic class where a person has a label and something they want to say
class Person
{
private:
char *szMessage;
char *szLabel;

public:
// Allow a person to deliver their message
void DeliverMessage()
{
printf("A now a message from %s: %s\n", this->szLabel, this->szMessage);
}

// A person needs to be initialized with a label and a message
Person(char*label, char *msg)
{
this->szLabel = label;
this->szMessage = msg;
}
};

// The King is a person (and thus inherits from it)
class King : public Person
{
public:
// The king has the same label, but his message might change according to the political winds
King(char *msg) : Person("the king", msg)
{
}

// Here, the function is being overridden...
void DeliverMessage()
{
// .. but the base class's DeliverMessage is still being called, in addition to the tag line
Person::DeliverMessage();
printf("The King has spoken!\n\n");
}
};

// A peon is a person (and thus inherits from it)
class Peon : public Person
{
public:
// A peon has the same label but his message might change according to his or her attitude toward the king
Peon(char *msg) : Person("a peon", msg)
{
}

// Like above, deliver the message, but always provide a common tag line
void DeliverMessage()
{
Person::DeliverMessage();
printf("... but don't mind me!\n\n");
}
};

// A jester is a person (and thus inherits from it)
class Jester : public Person
{
public:
// A peon has the same label but his message might change if the king is sick of his jokes
Jester(char *msg) : Person("the court jester", msg)
{
}

// Might as well call him Fozzie ;)
void DeliverMessage()
{
Person::DeliverMessage();
printf("Wocka wocka wocka!\n\n");
}
};
}

// Main program entry point
int main()
{
// Initialize some monarchy objects
Monarchy::King TheKing(KING_MESSAGE);
Monarchy::Jester Borat(JESTER_MESSAGE);
Monarchy::Peon Bruno(PEON_MESSAGE);

// Let them deliver their messages
TheKing.DeliverMessage();
Borat.DeliverMessage();
Bruno.DeliverMessage();

// Wait for user input
system("pause");

return 0;
}
#endif</pre>

==See also==
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Functional_programming Functional programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Programming_paradigm Programming paradigm] at Wikipedia
* [http://en.wikipedia.org/wiki/Class-based_programming Class-based programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Prototype-based_programming Prototype-based programming] at Wikipedia

==References==
<references/>

==Further reading==
* Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. ''Head First Design Patterns''. Sebastopol, CA: O'Reilly, 2004. Print.
* Liberty, Jesse. ''Sams Teach Yourself C++ in 24 Hours''. Indianapolis, IN: Sams, 2002. Print.
* ''Microsoft Visual C++ Language Reference''. Redmond, WA: Microsoft, 1997. Print.
* Weiss, Mark Allen. ''Data Structures & Algorithm Analysis in Java''. Reading, MA: Addison-Wesley, 1999. Print.
* Mohamed Fayad, Mauri Laitinen. "TRANSITION TO OBJECT-ORIENTED SOFTWARE DEVELOPMENT."

==External links==
* [http://www.slideshare.net/spajus/object-oriented-programming-presentation-933801 Object Oriented Programming] at slide'''share'''
* [http://www.developer.com/java/other/article.php/3493761/The-Evolution-of-Object-Oriented-Languages.htm The Evolution of Object-Oriented Languages]
* [http://www.xp2003.org/the-history-of-oop.htm The History of OOP]
* [http://www.brighthub.com/internet/web-development/articles/82024.aspx Structured vs. Object-Oriented Programming: A Comparison]

CSC/ECE 517 Fall 2011/ch1 1e sa

2011-09-15T20:04:51Z

Sramach5: /* Advantages */

"'''Block vs Object-Oriented Programming Languages'''"

In computer science, computer programming languages exhibit variance in syntax and structure in order to effectively solve problems. Two of these variances can be seen between '''block structure''' and '''object-oriented structure'''. A programming language with block structure allows the programmer to group lines of code for convenient use throughout the rest of the program. Object-oriented structure meanwhile goes further to allow the programmer to associate data with its actions in a hierarchical manner. Object-oriented structure has many advantages which generally make it more effective and durable than block-structured languages, but object-oriented languages also benefit from the core ideas present in block structure programming.

==Block structure==
===Definition===
Block-structured programming languages are task-centric, high-level languages. Operations on data sets are emphasized in an attempt to logically organize program operation. The design and implementation involves breaking down the problem into discrete blocks or units which can be nested to any depth or not at all. Each block generally consists of a set of delimiters such as braces or keywords that separate them from other blocks. Each of these blocks contains a set of (optional) declarations and logic to solve a particular problem. Declarations inside of nested blocks introduces the concept of variable scope, which frees the programmer from having to worry about name collisions and other variable maintenance tasks.<ref>[http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] at Wikipedia</ref> A [[CSC/ECE_517_Fall_2011/ch1_1e_sa#C.2FC.2B.2B_Code_Example|code example]] of a block structured program is provided later in the article.

Overall, block-structured languages can be summarized as having the following features:
* Modular - Lines of code/functionality are grouped together
* Scoped - Variables are limited to the group of code they are declared in
* [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Top down] - Modules are created as necessary to meet the program's requirements
* Simple - It is generally simpler to "cobble together" modules of code that accomplish a simple, well-defined task.

===History===
Block-structured languages were first conceived in the 1950s with the advent of [http://en.wikipedia.org/wiki/ALGOL ALGOL], one of the first [http://en.wikipedia.org/wiki/Imperative_programming imperative programming languages]. An evolution of block structuring was created as the "GOTO" logic of programs became more and more difficult to understand and maintain. In 1968, famed computer scientist [http://en.wikipedia.org/wiki/Edsger_W._Dijkstra Edsger Dijkstra] wrote [http://dx.doi.org/10.1145%2F362929.362947 a letter] and [http://dx.doi.org/10.1145%2F355604.361591 follow-up article] on the ideas and motivation behind "[http://en.wikipedia.org/wiki/Structured_programming structured programming]," where the program exhibits “[http://en.wikipedia.org/wiki/Separation_of_concerns separation of concerns]," single point of entry but multiple points of exit, and ideas of data structures. It was Dijkstra’s and others’ which helped propel this basic idea of block structure programming into the mainstream.<ref>[http://en.wikipedia.org/wiki/Structured_programming Structured programming] at Wikipedia</ref>

===Programming languages===
Block-structured programming languages dominate the general purpose, imperative programming language arena. Indeed most programming languages in modern use enjoy some of the benefits of block structure with grouping of code and scope of variables. Indeed, ignoring their object-oriented aspects, all of [http://en.wikipedia.org/wiki/C_(programming_language) C], [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#], [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/PHP PHP] and [http://en.wikipedia.org/wiki/Visual_Basic Visual Basic] – for example – contain elements of block structure.

==Object-oriented structure==
===Definition===
Object-oriented languages have an important overall goal and foster major design principles.
====Description====
Object-oriented structured languages are data-centric, high-level languages. This is in contrast to block structure languages, which are task-centric. Compared to block-structure languages, logical organization of data and the methods associated with them are emphasized. It is a way of grouping data with executable code. These groups are called "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]." Objects utilize their data and interact with other objects such that a hierarchy is established (called "[http://en.wikipedia.org/wiki/Class_(computer_science) classes]" in popular languages). Toward this end and depending on the language, objects can be interrelated and defined so that their relationships can produce code that is well-organized, easy to read, and reusable.<ref name="oopref">[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] at Wikipedia</ref>

====Principles====
=====Encapsulation=====
Also referred to as "data hiding," [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation] shields the programmer from the implementation details of an object. These implementation details would include [http://en.wikipedia.org/wiki/Local_variable private variables], special [http://en.wikipedia.org/wiki/Library_(computing) libraries], and [http://en.wikipedia.org/wiki/Data_structure data structures] that the programmer does not need to know in order to utilize the functionality offered by the object.<ref>[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation (object-oriented programming)] at Wikipedia</ref>

=====Inheritance=====
[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] introduces the idea of objects sharing functionality in data or methods that are common. [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses Subclasses] can inherit data structures, functions, and attributes of their [http://en.wikipedia.org/wiki/Subclass_(computer_science)#Subclasses_and_superclasses superclasses] in order to create an object or [http://en.wikipedia.org/wiki/Class_hierarchy class hierarchy] that is effective in organizing data and methods in a logical manner.<ref>[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance (computer science)] at Wikipedia</ref>

=====Polymorphism=====
[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism] describes the idea of interfaces, where one data type can be defined that allows other dissimilar types to implement a common set of [http://en.wikipedia.org/wiki/Method_(computer_programming) methods] and [http://en.wikipedia.org/wiki/Field_(computer_science) fields]. This allows a high level of [http://en.wikipedia.org/wiki/Abstraction_(computer_science) abstraction] that allows programmers to write easily maintainable code.<ref>[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism in object-oriented programming] at Wikipedia</ref>

===History and transition===
Early forms of object oriented programming languages were created in the early 1960s with the creation of [http://en.wikipedia.org/wiki/Lisp_(programming_language) LISP] and an early form of ALGOL, with [http://en.wikipedia.org/wiki/Simula Simula 67] signaling the actual beginning of the object-oriented "revolution." The development of object-oriented languages progressed through other languages like [http://en.wikipedia.org/wiki/Simula Smalltalk] and the archetypal C++ to arrive at many of the object oriented languages we have today.<ref name="oopref"/> As processing capability has matured, so too have the capabilities of programming languages. More and more though, [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic programming languages] like [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] are being treated as "true" object-oriented languages because of their rapid prototpying ability and strong [http://en.wikipedia.org/wiki/Object-oriented_analysis_and_design object model].

===Programming languages===
A complete list of object oriented languages is outside the scope of this document, but some major examples are [http://en.wikipedia.org/wiki/Boo_(programming_language) Boo], C++, C#, [http://en.wikipedia.org/wiki/COBOL COBOL 2002], [http://en.wikipedia.org/wiki/F_Sharp_(programming_language) F#], [http://en.wikipedia.org/wiki/Fortran Fortran 2003], Java, [http://en.wikipedia.org/wiki/Matlab MATLAB], [http://en.wikipedia.org/wiki/Objective_c Objective-C], [http://en.wikipedia.org/wiki/PHP PHP 5], [http://en.wikipedia.org/wiki/Python_(programming_language) Python], Ruby, and Visual Basic.<ref>[http://en.wikipedia.org/wiki/List_of_object-oriented_programming_languages List of object-oriented programming languages] at Wikipedia</ref>

==Structure comparison==
===Advantages and disadvantages===
==== Block-structured languages ====
=====Advantages=====
* Simplicity
* Reduced coding and turnover time
* Dynamic lifetime of variables ([http://en.wikipedia.org/wiki/Scope_(computer_science) Scope]) provide efficient usage of memory since allocation and deletion occur at the entrance and exit of each block

=====Disadvantages=====
* Commercial projects are difficult to manage due to very large [http://en.wikipedia.org/wiki/Codebase codebase] sizes
* Reduced code reusability
* [http://en.wikipedia.org/wiki/Computer_security Security] concerns, espcially in the realm of [http://en.wikipedia.org/wiki/Array#In_computer_science arrays] and accessing [http://en.wikipedia.org/wiki/Value_(computer_science) elements] that are [http://en.wikipedia.org/wiki/Privilege_(computing) out of bounds]

====Object-Oriented languages====
=====Advantages=====
* The software objects model real world objects so program composition is well defined and structured
* Each object's definition and internal implementation is decoupled from other objects, making the system design inherently modular ([http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation])
* Adding new features becomes easier because of inheritance, allowing the new class to contain the new feature in addition to all old features from the inherited class
* Debugging is easier since each object's internal mechanisms are independent of each other, which helps in isolating errors and fixing them
* Enhanced code reusability

=====Disadvantages=====
* The complexity of object-oriented design becomes prohibitive when working on small projects
* Object-oriented programming paradigm is preferable for dynamic environments rather than simple environments
* Reduced time efficiency compared to block-structured languages

===Summary of important differences===
{| class="wikitable" style="font-size: 100%; text-align: center; width: auto;"
|-
! Difference
! Block Structured Languages
! Object-Oriented Languages
|-
| '''Problem approach'''
| Top-down approach is followed
| [http://en.wikipedia.org/wiki/Top-down_and_bottom-up_design Bottom-up] approach is followed
|-
| '''Problem focus'''
| Focus is on the [http://en.wikipedia.org/wiki/Algorithm#Computer_algorithms algorithm] to solve the problem
| Focus is on getting the object design right
|-
| '''View of data and functions'''
| Views data and functions as separate entities
| Views data and functions as single entity
|-
| '''Cost of maintenance'''
| Maintenance is costly
| Maintenance is relatively cheaper
|-
| '''Software reuse'''
| Software reuse is not possible
| Software reuse is possible
|-
| '''Abstraction'''
| Function abstraction is used
| Data abstraction is used
|}

===Effectiveness and durability of object oriented languages over block structured languages ===

Although block structured languages were simpler and faster for smaller projects, when it comes to large commercial undertaking the manpower and tools required to maintain the code base is very prohibitive. It was very difficult to fix issues, add new features, and at the same time to make sure that the integrity of the code base is intact. Many projects were perpetually stagnant at 90% completion with issues coming up at the eleventh hour. All these problems led to the hastening of the move to object-oriented languages which showed it had the solutions to all the problems that block structured languages could not solve. The following four points are the most important reasons why object-oriented languages were more effective and durable that block structured languages:
* Maintenance - In block structured languages, especially in large projects, system maintenance became a challenge. Object oriented languages could counter this by providing clear demarcation between the objects and making it easier to work on individual aspects of the system without disturbing the other components.
* Data hiding - In block structured language system the data usually has global scope. Hence it is very difficult to monitor or supervise data access. This was solved by object-oriented languages by providing data encapsulation. The data and the corresponding attributes are put into a nice little package that was much easier to control and monitor.
* Code reuse - Object oriented languages are proponents of code reuse. Hence the code size could be reduced sufficiently enough when it comes to large projects to warrant a shift from block structured to object oriented languages.
* Feature additions - Object oriented languages provide a very cost effective and safe way to add new features to the existing system without causing the whole system to collapse. This feature is very important for large scale software vendors who provide various customizations.

===Applicability between paradigms===
Object-oriented languages have solved many problems that block structured languages introduced. But all is not lost with block structured languages. They boast some very important features that are needed in any programming language. The simplicity and readability of code in block structured languages are enviable features indeed. Because of this very simplicity we find that block structured languages are very efficient in terms of speed and performance. Such a language would also provide the flexibility in moving legacy block structured systems to the object oriented paradigm seamlessly. A language that can capture both sides of the argument would be a formidable entry into the growing list of programming languages. This explains why we see C++ emerging as one of the most popular object oriented languages. It has both the block structured features of C and the object-oriented concepts built into it, thereby making it a very versatile and efficient programming language.

==C/C++ Code Example==
{{Expand section}}
Below is a code example highlighting key differences between a block structured program and an object oriented program all in one source file.
<pre>// For block structure, leave the below line commented to compile in C
// For object oriented structure, uncomment the line to compile in C++
//#define USING_CPP

#ifndef USING_CPP

// C standard header files
#include <stdio.h>
#include <stdlib.h>

// Define the messages of each persona
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Define the function prototypes for delivering the different messages
char *getKingMessage();
char *getJesterMessage();
char *getPeonMessage();

// Main program entry point
int main()
{
// Go through and make each function call for...
// The King
printf("And now a message from the king: %s\n", getKingMessage());
printf("The King has spoken!\n\n");

// The Court Jester
printf("And now a message from the court jester: %s\n", getJesterMessage());
printf("Wocka wocka wocka!\n\n");

// A Peon
printf("And now a message from a peon: %s\n", getPeonMessage());
printf("... but don't mind me!\n\n");

// Wait for user input before exiting
system("pause");

return 0;
}

// Returns a string containing the text to be spoken by the king
char *getKingMessage()
{
return KING_MESSAGE;
}

// Returns a string containing the text to be spoken by the court jester
char *getJesterMessage()
{
return JESTER_MESSAGE;
}

// Returns a string containing the text to be spoken by all peons
char *getPeonMessage()
{
return PEON_MESSAGE;
}
#endif

#ifdef USING_CPP

// C++ standard headers
#include <cstdio>
#include <cstdlib>

// Define what each persona should say
#define KING_MESSAGE "Read my lips: No new taxes"
#define JESTER_MESSAGE "My wife and I were happy for 20 years. Then we met."
#define PEON_MESSAGE "The king himself created his own worst enemy, just as tyrants everywhere do!"

// Keep all classes clearly separated from other sections of code
namespace Monarchy
{
// Define a basic class where a person has a label and something they want to say
class Person
{
private:
char *szMessage;
char *szLabel;

public:
// Allow a person to deliver their message
void DeliverMessage()
{
printf("A now a message from %s: %s\n", this->szLabel, this->szMessage);
}

// A person needs to be initialized with a label and a message
Person(char*label, char *msg)
{
this->szLabel = label;
this->szMessage = msg;
}
};

// The King is a person (and thus inherits from it)
class King : public Person
{
public:
// The king has the same label, but his message might change according to the political winds
King(char *msg) : Person("the king", msg)
{
}

// Here, the function is being overridden...
void DeliverMessage()
{
// .. but the base class's DeliverMessage is still being called, in addition to the tag line
Person::DeliverMessage();
printf("The King has spoken!\n\n");
}
};

// A peon is a person (and thus inherits from it)
class Peon : public Person
{
public:
// A peon has the same label but his message might change according to his or her attitude toward the king
Peon(char *msg) : Person("a peon", msg)
{
}

// Like above, deliver the message, but always provide a common tag line
void DeliverMessage()
{
Person::DeliverMessage();
printf("... but don't mind me!\n\n");
}
};

// A jester is a person (and thus inherits from it)
class Jester : public Person
{
public:
// A peon has the same label but his message might change if the king is sick of his jokes
Jester(char *msg) : Person("the court jester", msg)
{
}

// Might as well call him Fozzie ;)
void DeliverMessage()
{
Person::DeliverMessage();
printf("Wocka wocka wocka!\n\n");
}
};
}

// Main program entry point
int main()
{
// Initialize some monarchy objects
Monarchy::King TheKing(KING_MESSAGE);
Monarchy::Jester Borat(JESTER_MESSAGE);
Monarchy::Peon Bruno(PEON_MESSAGE);

// Let them deliver their messages
TheKing.DeliverMessage();
Borat.DeliverMessage();
Bruno.DeliverMessage();

// Wait for user input
system("pause");

return 0;
}
#endif</pre>

==See also==
* [http://en.wikipedia.org/wiki/Imperative_programming Imperative programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Functional_programming Functional programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Programming_paradigm Programming paradigm] at Wikipedia
* [http://en.wikipedia.org/wiki/Class-based_programming Class-based programming] at Wikipedia
* [http://en.wikipedia.org/wiki/Prototype-based_programming Prototype-based programming] at Wikipedia

==References==
<references/>

==Further reading==
* Freeman, Eric, Elisabeth Freeman, Kathy Sierra, and Bert Bates. ''Head First Design Patterns''. Sebastopol, CA: O'Reilly, 2004. Print.
* Liberty, Jesse. ''Sams Teach Yourself C++ in 24 Hours''. Indianapolis, IN: Sams, 2002. Print.
* ''Microsoft Visual C++ Language Reference''. Redmond, WA: Microsoft, 1997. Print.
* Weiss, Mark Allen. ''Data Structures & Algorithm Analysis in Java''. Reading, MA: Addison-Wesley, 1999. Print.
* Mohamed Fayad, Mauri Laitinen. "TRANSITION TO OBJECT-ORIENTED SOFTWARE DEVELOPMENT."

==External links==
* [http://www.slideshare.net/spajus/object-oriented-programming-presentation-933801 Object Oriented Programming] at slide'''share'''
* [http://www.developer.com/java/other/article.php/3493761/The-Evolution-of-Object-Oriented-Languages.htm The Evolution of Object-Oriented Languages]
* [http://www.xp2003.org/the-history-of-oop.htm The History of OOP]
* [http://www.brighthub.com/internet/web-development/articles/82024.aspx Structured vs. Object-Oriented Programming: A Comparison]