Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-11-01T03:32:37Z

Vvarre: /* Using method_missing */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

The other way to create instance specific behavior to the object in the above example is:
<code>
foobar.instance_eval do
def size
"Hello World!"
end
end

foobar.size # => "Hello World!"
foobar.class # => Array
</code>

The following is the generic form of creating an instance specific behavior to the newly created object:
<code>
class << obj
def hello
'Hello World!'
end
end
</code>

The above code creates a singleton class for the object 'obj' with one instance specific method, 'hello' to it.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method Dynamic method creation]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/ Method_missing]</ref>.

Consider the following example:
<code>
lib/widget.rb
class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end
</code>

The following are used for testing the above example:
<code>
ruby-1.9.2-p0 > widget = Widget.new
=> #<Widget:0x0000010383f618>
ruby-1.9.2-p0 > widget.name = 'Bob'
=> "Bob"
ruby-1.9.2-p0 > widget.age = 30
=> 30
ruby-1.9.2-p0 > widget.name
=> "Bob"
ruby-1.9.2-p0 > widget.age
=> 30
</code>

When a object is called on any method, it first checks in its singleton class. Since, it is not found in this class it searches for the method in the original class to which it is referred and then only it searches for 'method_missing' method in the class. In the above example, a Widget object is created that can have any attributes we want to give it. The 'method_missing' checks if the called method ends with an equal sign, '='. If so, then it assigns the value that is passed to an instance variable with that name. If there is no equal sign, then it tries to get the value of instance variable by that name thus illustrating meta-programming concept in Ruby.;

The method with the name 'a_string' is not declared in the class and hence, it invokes the 'method_missing' method declared in the class and thereby dynamically creating thee . One of the ways Ruby is dynamic is that we can always choose to handle those methods that are called but don't actually exist. Ruby handles such an issue using the 'method_missing' method as illustrated above thus illustrating meta-programming in Ruby.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-11-01T03:32:10Z

Vvarre: /* Using method_missing */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

The other way to create instance specific behavior to the object in the above example is:
<code>
foobar.instance_eval do
def size
"Hello World!"
end
end

foobar.size # => "Hello World!"
foobar.class # => Array
</code>

The following is the generic form of creating an instance specific behavior to the newly created object:
<code>
class << obj
def hello
'Hello World!'
end
end
</code>

The above code creates a singleton class for the object 'obj' with one instance specific method, 'hello' to it.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method Dynamic method creation]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://kconrails.com/2010/12/21/dynamic-methods-in-ruby-with-method_missing/ Method_missing]</ref>.

Consider the following example:
<code>
# lib/widget.rb
class Widget
def method_missing sym, *args
if sym =~ /^(\w+)=$/
instance_variable_set "@#{$1}", args[0]
else
instance_variable_get "@#{sym}"
end
end
end
</code>

The following are used for testing the above example:
<code>
ruby-1.9.2-p0 > widget = Widget.new
=> #<Widget:0x0000010383f618>
ruby-1.9.2-p0 > widget.name = 'Bob'
=> "Bob"
ruby-1.9.2-p0 > widget.age = 30
=> 30
ruby-1.9.2-p0 > widget.name
=> "Bob"
ruby-1.9.2-p0 > widget.age
=> 30
</code>

When a object is called on any method, it first checks in its singleton class. Since, it is not found in this class it searches for the method in the original class to which it is referred and then only it searches for 'method_missing' method in the class. In the above example, a Widget object is created that can have any attributes we want to give it. The 'method_missing' checks if the called method ends with an equal sign, '='. If so, then it assigns the value that is passed to an instance variable with that name. If there is no equal sign, then it tries to get the value of instance variable by that name thus illustrating meta-programming concept in Ruby.;

The method with the name 'a_string' is not declared in the class and hence, it invokes the 'method_missing' method declared in the class and thereby dynamically creating thee . One of the ways Ruby is dynamic is that we can always choose to handle those methods that are called but don't actually exist. Ruby handles such an issue using the 'method_missing' method as illustrated above thus illustrating meta-programming in Ruby.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-11-01T02:52:29Z

Vvarre: /* Meta-programming in dynamically typed languages */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

The other way to create instance specific behavior to the object in the above example is:
<code>
foobar.instance_eval do
def size
"Hello World!"
end
end

foobar.size # => "Hello World!"
foobar.class # => Array
</code>

The following is the generic form of creating an instance specific behavior to the newly created object:
<code>
class << obj
def hello
'Hello World!'
end
end
</code>

The above code creates a singleton class for the object 'obj' with one instance specific method, 'hello' to it.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method Dynamic method creation]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, when the object is called on any method, it first checks in its singleton class. Since, it is not found in this class it searches for the method in the original class to which it is referred. The method with the name 'anything' is not created and hence, it invokes the 'method_missing' method declared in the class. One of the ways Ruby is dynamic is that we can always choose to handle those methods that are called but don't actually exist. Ruby handles such an issue using the 'method_missing' method as illustrated above thus illustrating meta-programming in Ruby.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T16:43:41Z

Vvarre: /* Introducing the Singleton class */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are. Ruby is the best example for the first kind where it is a dynamically typed language.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

The other way to create instance specific behavior to the object in the above example is:
<code>
foobar.instance_eval do
def size
"Hello World!"
end
end

foobar.size # => "Hello World!"
foobar.class # => Array
</code>

The following is the generic form of creating an instance specific behavior to the newly created object:
<code>
class << obj
def hello
'Hello World!'
end
end
</code>

The above code creates a singleton class for the object 'obj' with one instance specific method, 'hello' to it.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method Dynamic method creation]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, when the object is called on any method, it first checks in its singleton class. Since, it is not found in this class it searches for the method in the original class to which it is referred. The method with the name 'anything' is not created and hence, it invokes the 'method_missing' method declared in the class. One of the ways Ruby is dynamic is that we can always choose to handle those methods that are called but don't actually exist. Ruby handles such an issue using the 'method_missing' method as illustrated above thus illustrating meta-programming in Ruby.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T16:42:19Z

Vvarre: /* Introducing the Singleton class */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are. Ruby is the best example for the first kind where it is a dynamically typed language.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

The other way to create instance specific behavior to the object in the above example is:
<code>
foobar.insatnce_eval do
def size
"Hello World!"
end
end

foobar.size # => "Hello World!"
foobar.class # => Array
</code>

The following is the generic form of creating an instance specific behavior to the newly created object:
<code>
class << obj
def hello
'Hello World!'
end
end
</code>

The above code creates a singleton class for the object 'obj' with one instance specific method, 'hello' to it.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method Dynamic method creation]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, when the object is called on any method, it first checks in its singleton class. Since, it is not found in this class it searches for the method in the original class to which it is referred. The method with the name 'anything' is not created and hence, it invokes the 'method_missing' method declared in the class. One of the ways Ruby is dynamic is that we can always choose to handle those methods that are called but don't actually exist. Ruby handles such an issue using the 'method_missing' method as illustrated above thus illustrating meta-programming in Ruby.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T16:37:40Z

Vvarre: /* Introducing the Singleton class */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are. Ruby is the best example for the first kind where it is a dynamically typed language.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

The other way to create instance specific behavior to the object in the above example is:
<code>
foobar.insatnce_eval do
def size
"Hello World!"
end
end

foobar.size # => "Hello World!"
foobar.class # => Array
</code>

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method Dynamic method creation]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, when the object is called on any method, it first checks in its singleton class. Since, it is not found in this class it searches for the method in the original class to which it is referred. The method with the name 'anything' is not created and hence, it invokes the 'method_missing' method declared in the class. One of the ways Ruby is dynamic is that we can always choose to handle those methods that are called but don't actually exist. Ruby handles such an issue using the 'method_missing' method as illustrated above thus illustrating meta-programming in Ruby.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T16:32:41Z

Vvarre: /* Meta-programming in dynamically typed languages */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are. Ruby is the best example for the first kind where it is a dynamically typed language.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method Dynamic method creation]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, when the object is called on any method, it first checks in its singleton class. Since, it is not found in this class it searches for the method in the original class to which it is referred. The method with the name 'anything' is not created and hence, it invokes the 'method_missing' method declared in the class. One of the ways Ruby is dynamic is that we can always choose to handle those methods that are called but don't actually exist. Ruby handles such an issue using the 'method_missing' method as illustrated above thus illustrating meta-programming in Ruby.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T16:30:19Z

Vvarre: /* Using method_missing */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method Dynamic method creation]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, when the object is called on any method, it first checks in its singleton class. Since, it is not found in this class it searches for the method in the original class to which it is referred. The method with the name 'anything' is not created and hence, it invokes the 'method_missing' method declared in the class. One of the ways Ruby is dynamic is that we can always choose to handle those methods that are called but don't actually exist. Ruby handles such an issue using the 'method_missing' method as illustrated above thus illustrating meta-programming in Ruby.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T16:26:52Z

Vvarre: /* Using method_missing */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method Dynamic method creation]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, since there is no method named anything in the Dummy class, it searches and calls the method_missing in the class and executes. One of the way Ruby is dynamic is that we can always choose to handle those methods that are called but don't actually exist. Ruby handles such an issue using the 'method_missing' method as illustrated above thus illustrating meta-programming in Ruby.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T16:19:51Z

Vvarre: /* Using define_method */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method Dynamic method creation]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, since there is no method named anything in the Dummy class, it searches and calls the method_missing in the class and executes.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T16:18:39Z

Vvarre: /* Introducing the Singleton class */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.<ref>[http://onestepback.org/index.cgi/Tech/Ruby/Metaclasses.red Meta-classes]</ref>

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, since there is no method named anything in the Dummy class, it searches and calls the method_missing in the class and executes.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T16:16:35Z

Vvarre: /* Introducing the Singleton class */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.

The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end unless respond_to?(:singleton_class)
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, since there is no method named anything in the Dummy class, it searches and calls the method_missing in the class and executes.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T16:15:38Z

Vvarre: /* Introducing the Singleton class */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
A meta-class is a class whose instance are classes. Just as an ordinary class defines the behavior of certain objects, a meta-class defines the behavior of certain classes and their instances.We can understand two things from this that the instances of meta-classes are classes and that the meta-class defines the behavior of the class. The instances of the class are created using the class 'Class'(e.g., class.new) in Ruby. All classes are instances of Class. Also any class can have its own behavior by defining singleton methods in Ruby. Hence, the meta-classes are defined for Ruby. Further more, not all classes are singleton classes.. Only singleton classes of classes are meta-classes.
The following code returns the Object's singleton class.<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, since there is no method named anything in the Dummy class, it searches and calls the method_missing in the class and executes.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T15:50:24Z

Vvarre: /* Using define_method */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
The singleton meta-class can be accessed explicitly using the following<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax:<ref>[http://www.raulparolari.com/Ruby2/define_method]</ref>
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, since there is no method named anything in the Dummy class, it searches and calls the method_missing in the class and executes.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-31T15:47:29Z

Vvarre: /* Instance_eval and Class_eval */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
The singleton meta-class can be accessed explicitly using the following<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

====Using define_method====
We have seen above how we can create the methods dynamically. One more way of creating the methods dynamically is by using the 'define_method'. This keyword is used to define the methods with the following syntax.
define_symbol(symbol,method)
 where symbol specifies the method name; in spite of its name it can be either symbol, a string, or a variable whose value contains the method name and 'method' is a lambda or Proc object containing the method logic.


Let us consider the following example:
<code>
class C
define_method(:hello) do
puts "hello from hello method"
end
end

C.new.hello #=> "hello from hello method"
</code>

The above code creates an instance method 'hello' and is called using an object of the class and hence the output "hello from hello method".

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, since there is no method named anything in the Dummy class, it searches and calls the method_missing in the class and executes.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-20T23:56:46Z

Vvarre: /* Using method_missing */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
The singleton meta-class can be accessed explicitly using the following<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless a method called '''method_missing''' is provided. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, since there is no method named anything in the Dummy class, it searches and calls the method_missing in the class and executes.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-20T23:52:23Z

Vvarre: /* Meta-programming in dynamically typed languages */

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using [http://en.wikipedia.org/wiki/Decorator_pattern Decorators]<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
The singleton meta-class can be accessed explicitly using the following<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless you have provided the object with a method called '''method_missing'''. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, since there is no method named anything in the Dummy class, it searches and calls the method_missing in the class and executes.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011/ch4 4g nv

2011-10-20T22:47:08Z

Vvarre: Created page with "---- ==Introduction== [http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or t..."

----
==Introduction==
[http://en.wikipedia.org/wiki/Metaprogramming Meta-programming] in simple terms, is writing of computer programs to write or manipulate other programs (or themselves) as their data, or do that part of the work at compile time that would otherwise be done at runtime. Ruby has open classes which means that, at run time the definition of a class can be changed. All the classes in Ruby are open to be changed by the user at all times. Since, the Ruby class definitions are evaluated at run time, we can enter the world of meta-programming by accomplishing various tasks like compressing the code and so on. It allows how to define methods and classes even during the run-time.

By cleverly planning and applying the techniques of meta-programming, the code can be written efficiently that is DRYer, lighter, more intuitive and more scalable. Few primitive languages that support meta-programming includes Lisp which provides macros as a standard facility to write code that will be directly read and compiled by the system and Prolog which provides simple clause expansions that may be used to generate code as needed. Meta-programming involves thinking about the needs of the system and taking advantage of simpler specifications whenever possible.

==Meta-programming in dynamically typed languages==
[http://en.wikipedia.org/wiki/Dynamic_programming_language Dynamic programming languages] are a class of high-level programming languages that are executed at runtime with many common behaviors that other languages might perform during compilation, if at all. These behaviors could include program extension, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution. The common examples of dynamic languages are PHP, JavaScript, Perl, Ruby and Python. Most dynamic languages are dynamically typed, but not all are among which Ruby is the best example.

[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby]: Ruby is an interpreted scripting language for quick and easy object oriented programming. It is a dynamic, reflective language that has syntax similar to Perl and Python.
Example:
<code>
class A; end
A.class_eval do
def foo;
puts 'foo';
end
end

A.foo # => Gives the error saying NoMethodError
A.new.foo # => Gives the output as "foo"
</code>

[http://en.wikipedia.org/wiki/Python_(programming_language) Python]: Python is an interpreted, object-oriented language that combined with dynamic typing and dynamic binding.
Metaprogramming in python is supported using Decorators<ref> [http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/ Meta-programming in Python]</ref>.
Example:
<code>
Class Ninja(object):
def __init__(self,name) :
self.name = name

drew = Ninja(‘drew’)
adam = Ninja(‘adam’)
</code>

Adding a method to the class:
<code>
def battle_cry(self)
print ‘%s says zing!!’ % self.name
Ninja.battle_cry = battle_cry

Drew.battle_cry() # => Drew says zing!!
Adam.battle_cry() # => Adam says zing!!
</code>

Adding a method to an instance:
<code>
import types
def throw_star(self)
print ‘throwing a star’
drew.throw_star = types.MethodType(throw_star,drew)

drew.throw_star() # => throwing a star
drew.__getattribute__(‘battle_cry’)() # => Drew says zing!! {Invoking the method dynamically}
</code>

The decorators enhance the original function by adding the functionality of element wise. Now, we can operate on one thing or a series of things which can be applicable efficiently in many dynamic programming situations.

==Ways to implement Meta-programming==
=== Introducing the Singleton class ===

The basic fundamental feature of metaprogramming is Singleton. The [http://www.wikyblog.com/AmanKing/Singleton%20class%20in%20Ruby Singleton class] is the class created for an object if the Ruby interpreter needs to add an instance-specific behavior for that object. All objects in Ruby are open to modification and any particular instance of any class can be changed. Ruby allows us to add a new method to a single object. If there is only one single object that requires addition, alteration or deletion, introducing singleton class is the best way to accomplish this objective. A singleton class is a class whose number of instances that can be instantiated is limited to one. The singleton for class objects is called as [http://en.wikipedia.org/wiki/Metaclass Meta-class].

With access to a class object’s meta-class we can then use meta-programming techniques of Ruby to enhance the class<ref>[http://www.devalot.com/articles/2008/09/ruby-singleton Concept of Singleton class]</ref>.
Let us look at the following example:
<code>
foobar = Array.new
def foobar.size
"Hello World!"
end

foobar.size # => "Hello World!"
foobar.class # => Array

bizbat = Array.new
bizbat.size # => 0
</code>

In the above example, a new object of Array is created and we are adding methods to the object. This way only the object can access the modified method size unlike the other objects of the same class that have access to the method of the original class. This way any number of methods can be added with the singleton class.

In Ruby, the Singleton class itself is treated as a receiver. When any method is added to a specific object, Ruby inserts a new anonymous class called a Singleton class into the hierarchy as a container to hold these types of methods.
The singleton meta-class can be accessed explicitly using the following<ref>[http://www.slideshare.net/bsbodden/ruby-metaprogramming-08 Singleton Class]</ref>:

<code>
module Kernel
def singleton_class
class << self
self
end
end
end
</code>

===Method Aliasing===

Aliasing means giving a second name to a method or variable. '''Method Aliasing''' is primarily used to override methods and change behavior of classes and objects in order to provide more expressive options to programmers. Ruby provides this functionality with the alias and alias_method keywords. The alias keyword takes two arguments: the old method/variable name and the new method/variable name and create a new name that refers to an existing method, operator, global variable, or regular expression backreference ($&, $`, $', and $+). The method names should be passed as symbols which are immutable as opposed to mutable strings. Aliasing cannot be effectively applied on local variables ,instance variables and constants<ref>[http://ruby.about.com/od/rubyfeatures/a/aliasing.htm Method aliasing]</ref>.
General syntax for aliasing is:-
alias_attribute(new_name, old_name)

<code>
class Objectcount
attr_accessor :count
alias :number :count # alias for getter
def initialize(cnt)
@count = cnt
end
end

a = Objectcount.new(5)
puts a.number
</code>

In the following example, start is defined as alias of method begun, and hence object of the class Race can invoke begun method using r.start.

<code>
class Race
def begun
puts "Race Started"
end

alias :start :begun
end

r = Race.new
r.start # should refer to r.begun
</code>

The behavior of any class can be changed by creating an alias for any method and then creating a new method (with the original method name) that calls the method with the alias. Aliases and methods to individual objects can also be addes using a syntax similar to the inherited class syntax. Following example illustrate a way to override the behavior of some method without changing its original implementation. In the following example, a Tax class is declared and an instance is created. The class declaration uses the alias to alter the behavior of payment method to display the payment type from monthly to yearly.

<code>
class Tax
def payment
puts "Monthly Bill"
end
alias_method :expenditure, :payment
def payment
puts "Yearly Bill "
expenditure
end
end

tx = Tax.new
tx.payment
</code>

<code>
Output:
" Yearly Bill "
" Monthly Bill "
</code>

'''Problem with Aliasing'''
*Aliases encourage Monkeypatching and thus hold the possiblity of breaking the existing code. Look back at the last section. Adding a alias for String#length breaks libraries that expect the “length” of a string to be its size in bytes. Following can provide a workaround for such issues :-

<code>
class String
alias :real_length :length
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
"Hello World".real_length # => 11
</code>

*Loading an Alias twice also disrupt the behaviour and throws exceptions.

===Class Definitions===
In languages such as C++ and Java, class definitions are processed at compile time which require compiler to load symbol tables, work out storage allocation and constructs dispatch tables. Whereas, in Ruby, class and module definitions are executable code which are parsed at compile time, but created at runtime when they are encountered. This flexiblity allow users to structure programs dynamically. Classes in Ruby are not closed and can thus be extended to add new methods at runtime. Even core system classes like String, Array, and Fixum can be extended just by reopening the class and adding new code<ref>[http://juixe.com/techknow/index.php/2007/01/17/reopening-ruby-classes-2/ Classes and Methods]</ref>. For example :

Redefine existing method:
<code>
class String
def length
real_length > 5 ? 'long' : 'short'
end
end

"Hello World".length # => "long"
</code>

Add new method:
<code>
# reopen the class
String.class_eval do
# define new method
def get_size
# method implementation
length
end
end
</code>

A Ruby class is an object of class Class, which contains objects, list of methods and a reference to a superclass. All method calls in Ruby nominate a receiver (self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receiver's class. If it doesn't find the method there, it looks in the superclass, and then in the superclass's superclass, and so on. If the method cannot be found in the receiver's class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

====Instance_eval and Class_eval====

There are several versions of evaluation primitives in Ruby. The available contestants are eval, instance_eval, module_eval and class_eval. Firstly, class_eval is an alias for module_eval. Second, there are some differences between eval and the others. Importantly, eval takes only a string to evaluate while the others can evaluate a block instead. The eval involves many complexities and should be the last way to do anything. In most of the cases, we can get away with just evaluating blocks with instance_eval and block_eval.

In a class (or module) definition, the class itself takes the role of the current object self. When you define a method, that method becomes an instance method of the current class. Module#class_eval( ) (also known by its alternate name, module_eval( )) evaluates a block in the context of an existing class. instance_eval( ) only changes self, while class_eval( ) changes both self and the current class. By changing the current class, class_eval( ) effectively reopens the class, just like the class keyword does.

Instance_eval will evaluate the string or the block in the context of the receiver which means that self will be set to the receiver while evaluating. class_eval will evaluate the string or the block in the context of the module it is called on. Instance_eval opens an object that is not a class whereas class_eval() opens a class definition and defines methods with def<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Instance_eval and Class_eval]</ref>.

Consider the example illustrating class_eval:

<code>
class Person
end

Person.class_eval do
def say_hello
"Hello!"
end
end

jimmy = Person.new
jimmy.say_hello # => "Hello!"
</code>

Consider the following example illustrating instance_eval:
<code>
class Person
end

Person.instance_eval do
def human?
true
end
end

Person.human? # => true
</code>

Evaluation Table: In the following table, new scope means that code inside the block does not have access to local variables outside of the block. Each object in Ruby has its own metaclass, which is a Class that can have methods, but is only attached to the object itself.
{| class="wikitable" border="1"
|-
! Mechanism
! Method Resolution
! Method Definition
! New Scope
|-
| Class Person
| Person
| Same
| Yes
|-
| Class << Person
| Person's metaclass
| Same
| Yes
|-
| Person.class_eval
| Person
| Same
| No
|-
| Person.instance_eval
| Person
| Person's metaclass
| No
|}

====Using method_missing====

When any message is sent to an object, the object executes the first method it finds on its method lookup path with the same name as the message. Method lookup path is nothing but the class in hierarchy to the Object class. If it fails to find any such method, it raises a NoMethodError exception unless you have provided the object with a method called '''method_missing'''. This method is passed with the symbol of the non-existent method, an array of arguments that were passed in the original call and any block passed to the original method<ref>[http://rubylearning.com/satishtalim/ruby_method_missing.html Method_missing]</ref>.

Consider the following example:
<code>
class Dummy
def method_missing(m, *args, &block)
puts "There's no method called #{m} here -- please try again."
end
end

Dummy.new.anything

The output is:
There's no method called anything here -- please try again.
</code>

In the above example, since there is no method named anything in the Dummy class, it searches and calls the method_missing in the class and executes.

====Singleton methods====
[http://stackoverflow.com/questions/212407/what-exactly-is-the-singleton-class-in-ruby Singleton method] is a method that is defined only for a single object. Singleton methods helps in customizing specific instance of a class and thus escape from the need of defining another class, which would then only be instantiated once. In ruby we can give any object its own methods<ref> [http://www.rubyist.net/~slagell/ruby/ Singleton Methods] </ref>.

<code>
class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new

def test2.size
10
end

test1.size # => 25
test2.size # => 10
</code>

In this example, test1 and test2 belong to same class, but test2 has been given a redefined size method and so they behave differently. A method given only to a single object is called a singleton method.Singleton methods are often used for elements of a graphic user interface (GUI), where different actions need to be taken when different buttons are pressed.

===Modules===
Modules are a way of grouping methods, classes, and constants. The major benefits using modules is that they provide a namespace and prevent name clashes. They also implement the mixin facility. Ruby allows you to create and modify classes and modules dynamically. Almost any operation can be done on any class or module that isn’t frozen.

Modules have simple access to the method behavior to anyone who wishes to alter but reuse the original behavior. This fact could be applied to both classes that include modules and instances that extend the modules.

'''Include:''' Module.include is generally used to mix modules into classes and other modules. Whenever a module is included the constants, methods and the variables of the modules are added to the including module or class instances. This include statement causes all methods in modules to be added as the instance methods and the constants can also be accessed through the method whereas the extend statement adds all the methods as class methods and does nothing with the constants<ref>[http://blog.jayfields.com/2006/05/ruby-extend-and-include.html Extending modules]</ref>.

Consider the following example:
<code>
module Actions
def left(steps)
Movement.new(self, steps)
end
end
</code>

The Actions module can be included to allow a class to generate movements.

<code>
class Car
include Actions
end
</code>

After Actions is included left can be executed by any instance of Car.

<code>
car = Car.new
movement = car.left
</code>

Similarly, '''Object.extend'''(module, ..) adds the instance methods from each module given as a parameter. However, extend adds the methods to one instance, not to all instances.

<code>
car = Car.new
car.extend Actions
movement = car.left
</code>

The above code gives car the same behavior as include would, except only the instance that called extend would have this new behavior. Therefore, the above code is valid, but this code would result in an error:

<code>
car = Car.new
car.extend Actions
car2 = Car.new
movement = car2.left # calling 'left' here is invalid because car2 does not extend Actions.
</code>

Extend is commonly used to mix instance methods of a module into a class. Ruby invokes included or extended methods in the module, if they exist, when the module is included or extended respectively. These have to be defined as class methods - even though this is not a class. Both these methods should take a single parameter; the object or class to which the module is being added<ref>[http://strugglingwithruby.blogspot.com/2009/02/modules.html Modules]</ref>.
Let us consider the following example:

<code>
module TestModule
def self.included base
p "I am being included by #{base}"
end
def self.extended base
p "I am being extended by #{base}"
end
end

class TestClass1
include TestModule
end

class TestClass2
extend TestModule
end

p 'Classes now defined'

tc2 = TestClass2.new
tc2.extend TestModule

Output:
"I am being included by TestClass1"
"I am being extended by TestClass2"
"Classes now defined"
"I am being extended by #<TestClass2:0x987a33>”
</code>

===Other ways to implement Meta-programming===
*'''Introspect on instance variables:''' A trick that Rails uses to make instance variables from the controller available in the view is to introspect on an objects instance variables. It's easy to do with instance_variables, using instance_variable_get and instance_variable_set. We could copy all the instance variables from one object to another using to accomplish this property.
*'''Create Procs from blocks and send them around:''' Materializing a Proc and saving this in variables and sending it around makes many API's very easy to use. This is one of the ways markably used to manage those CSS class definitions.

==Advantages of Meta-programming==
*It is a new set of conceptual tools that eliminates duplication form your code.
*It allows us to create more expressive APIs than without it and can accomplish some things with significantly less code.
*Ruby can enter into the field of Artificial Intelligence.
*In Real-time, as the analysis is done at runtime any changes to the data model can be reflected in the application at real-time.

==Conclusions==
Ruby’s way to enhance a class using metaprogramming is seamless, powerful, and built right into the language itself. Metaprogramming helps in keeping code simple and precise. For the most part, the only code that exists in your classes is custom methods to handle specific business rules and other specific one-off customizations.

==References==
<references/>

==See Also==
*http://rosettacode.org/wiki/Metaprogramming
*http://rubysource.com/ruby-metaprogramming-part-i/
*http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
*http://ruby-doc.org/docs/ProgrammingRuby/html/classes.html

CSC/ECE 517 Fall 2011

2011-10-20T02:43:57Z

Vvarre:

[[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]]

*[[trial]]

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-26T03:10:28Z

Vvarre: /* References */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages whose structures are modularized into sections of code enclosed between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm Structured Programming] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers learning Object Oriented Programming] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Compare and contrast structured and object oriented]</ref> <ref>[http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs. Object oriented Programming]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.<ref>[http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure necessary]</ref>

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

==External Links==
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-26T03:09:59Z

Vvarre: /* References */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages whose structures are modularized into sections of code enclosed between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm Structured Programming] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers learning Object Oriented Programming] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Compare and contrast structured and object oriented]</ref> <ref>[http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs. Object oriented Programming]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.<ref>[http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure necessary]</ref>

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-26T03:04:11Z

Vvarre:

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T22:26:11Z

Vvarre: /* Introduction */

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T22:13:43Z

Vvarre: /* Comparision between Block Structured and OO Programming */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm Structured Programming] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers learning Object Oriented Programming] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Compare and contrast structured and object oriented]</ref> <ref>[http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs. Object oriented Programming]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.<ref>[http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure necessary]</ref>

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T22:12:57Z

Vvarre: /* Usage of Block Structures in Object Oriented Programming */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm Structured Programming] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers learning Object Oriented Programming] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Compare and contrast structured and object oriented]</ref> <ref>[http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.<ref>[http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure necessary]</ref>

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T22:12:25Z

Vvarre: /* Usage of Block Structures in Object Oriented Programming */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm Structured Programming] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers learning Object Oriented Programming] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Compare and contrast structured and object oriented]</ref> <ref>[http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.<ref>[ http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure necessary]</ref>

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T22:11:41Z

Vvarre: /* Usage of Block Structures in Object Oriented Programming */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm Structured Programming] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers learning Object Oriented Programming] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Compare and contrast structured and object oriented]</ref> <ref>[http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.<ref>[ http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf]</ref>

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T22:08:16Z

Vvarre: /* Comparision between Block Structured and OO Programming */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm Structured Programming] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers learning Object Oriented Programming] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Compare and contrast structured and object oriented]</ref> <ref>[http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T22:00:57Z

Vvarre: /* History */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm Structured Programming] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers learning Object Oriented Programming] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Compare and contrast structured and object oriented]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:59:38Z

Vvarre: /* History */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm Structured Programming] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Compare and contrast structured and object oriented]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:58:49Z

Vvarre: /* Comparision between Block Structured and OO Programming */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Compare and contrast structured and object oriented]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:57:10Z

Vvarre: /* What is Object-Oriented Programming? */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:55:45Z

Vvarre: /* What is Object-Oriented Programming? */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure<ref>[http://www.delphibasics.co.uk/Article.asp?Name=OO ]</ref>.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:53:12Z

Vvarre: /* Comparision between Block Structured and OO Programming */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''<ref>[http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573]</ref>

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:49:44Z

Vvarre: /* History */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm] </ref>.

The principle idea behind structured programming <ref>[http://bulletin.sigchi.org/1997/october/papers/ross/] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:49:13Z

Vvarre: /* History */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm] </ref>.

The principle idea behind structured programming </ref> [http://bulletin.sigchi.org/1997/october/papers/ross/] </ref> was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:47:05Z

Vvarre: /* History */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming <ref> [http://www.wisegeek.com/what-is-structured-programming.htm] </ref>.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:43:30Z

Vvarre: /* References */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
<references/>

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:42:54Z

Vvarre: /* What is a Block-Structured Programming? */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming <ref> [http://en.wikipedia.org/wiki/Block_(programming) Block (programming)] </ref> languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T21:29:52Z

Vvarre: /* What is Object-Oriented Programming? */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

Below is an example of the code from JAVA language where there are two classes, Tree and PlantTrees and three objects are created to find the heights for each of the three objects.

<code>
class Tree
{
public int height = 0;
public void grow()
{
height = height + 1;
}
}
class PlantTrees
{
public static void main(String[] args)
{
System.out.println("Let's plant some trees!");
Tree tree1 = new Tree();
System.out.println("I've created a tree with a height of " + tree1.height + " meter(s).");
tree1.grow();
System.out.println("After a bit of growth, it is now up to " + tree1.height + " meter(s) tall.");
Tree tree2 = new Tree();
Tree tree3 = new Tree();
tree2.grow();
tree3.grow();
tree2.grow();
tree3.grow();
tree2.grow();
System.out.println("Here are the final heights:");
System.out.println(" tree1: " + tree1.height + "m");
System.out.println(" tree2: " + tree2.height + "m");
System.out.println(" tree3: " + tree3.height + "m");
}
}
</code>

Code Output:

<code>
Let's plant some trees!
I've created a tree with a height of 0 meter(s).
After a bit of growth, it is now up to 1 meter(s) tall.
Here are the final heights:
tree1: 1m
tree2: 3m
tree3: 2m
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T14:23:48Z

Vvarre: /* What is Object-Oriented Programming? */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

Below is an example of the code from JAVA language that is swapping two numbers by calling a new function swap from the main and by using a temporary variable temp. First the two numbers to be swapped are entered, then the swap function is called where it uses the temporary variable to swap both the numbers.

<code>
public class SwapElementsExample
{

public static void main(String[] args)
{

int num1 = 10;
int num2 = 20;

System.out.println("Before Swapping");
System.out.println("Value of num1 is :" + num1);
System.out.println("Value of num2 is :" +num2);

//swap the value
swap(num1, num2);
}

private static void swap(int num1, int num2)
{

int temp = num1;
num1 = num2;
num2 = temp;

System.out.println("After Swapping");
System.out.println("Value of num1 is :" + num1);
System.out.println("Value of num2 is :" +num2);

}
}
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2011/ch1 1e vs

2011-09-25T14:07:09Z

Vvarre: /* What is a Block-Structured Programming? */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

The code snippet in [http://en.wikipedia.org/wiki/ALGOL ALGOL] below is an example which calculates the arithmetic mean by taking the number of samples and then asking for the values of the samples. It is block structured because of its modularized sections of code with the "begin" and "end" keywords. The scope of variables depends on where they are declared in the program. For example, N is an integer that has scope throughout the code whereas the array, sum, avg variables have the scope after reading the number of samples and the val variable has the local scope inside the for loop where the values are read for each sample.

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

An example of the code from JAVA language is as follows:

<code>
Class HelloWorld
{
public static void main(String args[])
{
System.out.println("Hello world!"):
System.out.println("Arguments you have entered is:");
if (args.length>0)
{
for(int i=0;i<args.length;i++)
{
System.out.print(args[i]+" ");
}
System.out.println();
}
else
System.out.println("<<No Arguments>>");
}
}
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-16T14:34:45Z

Vvarre: /* What is a Block-Structured Programming? */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

An example of a block in [http://en.wikipedia.org/wiki/ALGOL ALGOL] looks as shown below:

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

An example of the code from JAVA language is as follows:

<code>
Class HelloWorld
{
public static void main(String args[])
{
System.out.println("Hello world!"):
System.out.println("Arguments you have entered is:");
if (args.length>0)
{
for(int i=0;i<args.length;i++)
{
System.out.print(args[i]+" ");
}
System.out.println();
}
else
System.out.println("<<No Arguments>>");
}
}
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-16T14:29:55Z

Vvarre: /* What is a Block-Structured Programming? */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..<ref>[http://en.wikipedia.org/wiki/Block_(programming)]Block programming </ref>

An example of a block in [http://en.wikipedia.org/wiki/ALGOL ALGOL] looks as shown below:

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

An example of the code from JAVA language is as follows:

<code>
Class HelloWorld
{
public static void main(String args[])
{
System.out.println("Hello world!"):
System.out.println("Arguments you have entered is:");
if (args.length>0)
{
for(int i=0;i<args.length;i++)
{
System.out.print(args[i]+" ");
}
System.out.println();
}
else
System.out.println("<<No Arguments>>");
}
}
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-16T13:48:08Z

Vvarre: /* Introduction */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
Block structured languages are those languages that have have a syntax of enclosed structures between bracketed keywords. The object oriented languages are those which are organized around data rather than logic. The article presented mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

An example of a block in [http://en.wikipedia.org/wiki/ALGOL ALGOL] looks as shown below:

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

An example of the code from JAVA language is as follows:

<code>
Class HelloWorld
{
public static void main(String args[])
{
System.out.println("Hello world!"):
System.out.println("Arguments you have entered is:");
if (args.length>0)
{
for(int i=0;i<args.length;i++)
{
System.out.print(args[i]+" ");
}
System.out.println();
}
else
System.out.println("<<No Arguments>>");
}
}
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-16T06:28:23Z

Vvarre: /* Conclusion */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
This article mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

An example of a block in [http://en.wikipedia.org/wiki/ALGOL ALGOL] looks as shown below:

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

An example of the code from JAVA language is as follows:

<code>
Class HelloWorld
{
public static void main(String args[])
{
System.out.println("Hello world!"):
System.out.println("Arguments you have entered is:");
if (args.length>0)
{
for(int i=0;i<args.length;i++)
{
System.out.print(args[i]+" ");
}
System.out.println();
}
else
System.out.println("<<No Arguments>>");
}
}
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of [http://en.wiktionary.org/wiki/tramp_data tramp data].

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to the above needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.

* Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

*The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear.

The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability.
*Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program.
*Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones.
*Maintanability is the feature where the objects can be maintained and the problems can be fixed easier.
*Reusability is a very important feature where the objects can be reused in different programs.

This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:

'''Usage of Blocks in Ruby:'''

In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in Java:'''

Java also uses blocks in many situations like in conditional structures like if and else, looping constructs like "while", "for" etc.
Let us for instance consider the while statement.The while statement continually executes a block of statements while a particular condition is true. Its syntax can be expressed as follows:

<code>
while (expression) {
statement(s)
}
</code>

The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the following PrintCount program:

<code>
class PrintCount {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
}
}
</code>

The statements included in the while block are blocks of code and cannot be avoided in situations such as these.This clearly proves that usage of blocks is not pertinent only to Block Structured Languages but also applies to Object Oriented languages as well.
Hence, blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus in conclusion we can say that, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code. Although Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are preferred in the present scenario because of the above mentioned features. The more complicated the project, the easier it is to leverage the strengths of object oriented design.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-08T17:52:49Z

Vvarre: /* Conclusion */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
This article mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

An example of a block in [http://en.wikipedia.org/wiki/ALGOL ALGOL] looks as shown below:

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

An example of the code from JAVA language is as follows:

<code>
Class HelloWorld
{
public static void main(String args[])
{
System.out.println("Hello world!"):
System.out.println("Arguments you have entered is:");
if (args.length>0)
{
for(int i=0;i<args.length;i++)
{
System.out.print(args[i]+" ");
}
System.out.println();
}
else
System.out.println("<<No Arguments>>");
}
}
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of "tramp data"

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to these needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear. The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability. Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program. Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones. Maintanability is the feature where the objects can be maintained and the problems can be fixed easier. Reusability is a very important feature where the objects can be reused in different programs.
This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:
In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in CPP:'''

C++ also uses blocks in many situations like in conditional structures like if and else.
The if keyword is used to execute a statement or block only if a condition is fulfilled. Its form is:

if (condition) statement

Where condition is the expression that is being evaluated. If this condition is true, statement is executed. If it is false, statement is ignored (not executed) and the program continues right after this conditional structure.
For example, the following code fragment prints x is 100 only if the value stored in the x variable is indeed 100:

<code>
if (x == 100)
cout << "x is 100";
</code>

If we want more than a single statement to be executed in case that the condition is true we can specify a block using braces { }:

<code>
if (x == 100)
{
cout << "x is ";
cout << x;
}
</code>

Hence, as seen above blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus we can say that though Block Structured languages and Object Oriented languages have their own advantages, Object oriented languages are definitely better and are preferred in the present scenario because of the above mentioned features. Also as we have seen above, the structure of a block can be used in Object Oriented programming as it provides a better understanding of the code.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-08T17:43:51Z

Vvarre: /* What is a Block-Structured Programming? */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
This article mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements enclosed within the bracketed keywords like if....fi.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..

An example of a block in [http://en.wikipedia.org/wiki/ALGOL ALGOL] looks as shown below:

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

An example of the code from JAVA language is as follows:

<code>
Class HelloWorld
{
public static void main(String args[])
{
System.out.println("Hello world!"):
System.out.println("Arguments you have entered is:");
if (args.length>0)
{
for(int i=0;i<args.length;i++)
{
System.out.print(args[i]+" ");
}
System.out.println();
}
else
System.out.println("<<No Arguments>>");
}
}
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of "tramp data"

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to these needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear. The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability. Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program. Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones. Maintanability is the feature where the objects can be maintained and the problems can be fixed easier. Reusability is a very important feature where the objects can be reused in different programs.
This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:
In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in CPP:'''

C++ also uses blocks in many situations like in conditional structures like if and else.
The if keyword is used to execute a statement or block only if a condition is fulfilled. Its form is:

if (condition) statement

Where condition is the expression that is being evaluated. If this condition is true, statement is executed. If it is false, statement is ignored (not executed) and the program continues right after this conditional structure.
For example, the following code fragment prints x is 100 only if the value stored in the x variable is indeed 100:

<code>
if (x == 100)
cout << "x is 100";
</code>

If we want more than a single statement to be executed in case that the condition is true we can specify a block using braces { }:

<code>
if (x == 100)
{
cout << "x is ";
cout << x;
}
</code>

Hence, as seen above blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus we can say that though these languages have their own advantages, Object oriented languages are preferred for the present scenario because of the above seen features.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-08T17:41:22Z

Vvarre: /* What is Object-Oriented Programming? */

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
This article mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..
Block structured languages have a syntax such that the structures are enclosed within the bracketed keywords like if....fi in [http://en.wikipedia.org/wiki/ALGOL ALGOL] language.

An example of a block in [http://en.wikipedia.org/wiki/ALGOL ALGOL] looks as shown below:

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

An example of the code from JAVA language is as follows:

<code>
Class HelloWorld
{
public static void main(String args[])
{
System.out.println("Hello world!"):
System.out.println("Arguments you have entered is:");
if (args.length>0)
{
for(int i=0;i<args.length;i++)
{
System.out.print(args[i]+" ");
}
System.out.println();
}
else
System.out.println("<<No Arguments>>");
}
}
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of "tramp data"

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to these needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear. The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability. Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program. Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones. Maintanability is the feature where the objects can be maintained and the problems can be fixed easier. Reusability is a very important feature where the objects can be reused in different programs.
This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:
In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in CPP:'''

C++ also uses blocks in many situations like in conditional structures like if and else.
The if keyword is used to execute a statement or block only if a condition is fulfilled. Its form is:

if (condition) statement

Where condition is the expression that is being evaluated. If this condition is true, statement is executed. If it is false, statement is ignored (not executed) and the program continues right after this conditional structure.
For example, the following code fragment prints x is 100 only if the value stored in the x variable is indeed 100:

<code>
if (x == 100)
cout << "x is 100";
</code>

If we want more than a single statement to be executed in case that the condition is true we can specify a block using braces { }:

<code>
if (x == 100)
{
cout << "x is ";
cout << x;
}
</code>

Hence, as seen above blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus we can say that though these languages have their own advantages, Object oriented languages are preferred for the present scenario because of the above seen features.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP

CSC/ECE 517 Fall 2010/ch1 1e vs

2011-09-08T17:40:34Z

Vvarre:

CSC/ECE 517 Fall 2010/ch1 1e vs
----
==Introduction==
This article mainly compares and contrasts [http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] and [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented programming] and focuses on the advantages of Object-Oriented programming over Block-structured programming. It also emphasizes on the usage of block structures in Object-Oriented programming.

==What is a Block-Structured Programming?==
A block is a section of [http://en.wikipedia.org/wiki/Computer_code code] which is grouped together and consists of one or more declarations and statements.

A block structured programming languages is a class of high level programming languages that allows the creation of blocks and includes the nested blocks as components where nesting could be extended to any depth. Some examples of block structured languages are: [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/Pascal_(programming_language PASCAL],[http://en.wikipedia.org/wiki/Fortran FORTRAN] etc..
Block structured languages have a syntax such that the structures are enclosed within the bracketed keywords like if....fi in [http://en.wikipedia.org/wiki/ALGOL ALGOL] language.

An example of a block in [http://en.wikipedia.org/wiki/ALGOL ALGOL] looks as shown below:

<code>
begin
integer N;
Read Int(N);
begin
real array Data[1:N]
real sum,avg;
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
</code>

===Features===

The essential composition of block structured programming tends to include three basic elements:

*'''Concatenation:''' Concatenation is the element which is responsible for the logical sequence of the statements that make up the basics for the order to be executed.

*'''Selection:''' Selection is the second element included in the process of structural programming which allows selection of any one of a number of statements to execute, based on the current status of the program. Generally, the selection statements contain keywords like “if,” “then,” “endif,” or “switch” to identify the order as a logical executable.

*'''Repetition:''' In repetition a selected statement remains active until the program reaches a point where there is a need for some other action to take place. Repetition normally includes keywords such as ”repeat,” “for,” or “do…until.” Essentially, repetition instructs the program how long to continue the function before requesting further instructions.

The exact nature of block structured programming will varies depending on the purpose and function of the program.

===Advantages===
*Restricted visibility to local identifiers.

*Efficient use of storage.

*Learning and programming of the language is both quick and relatively easy.

*Turn around time is likely to be quite rapid, since the number of de-bugging runs is usually small.

===Limitations===
*Focus is given on the procedure (logic) and not to the data on which these procedures operate.
*The data need to be global but global data makes the code complex.
*As the code size grows, maintaining code becomes difficult and sometimes impossible.
*Structured programming language is not ‘modular’ i.e., no reuse of code leading to redundant code.

==What is Object-Oriented Programming?==
Object-Oriented programming is a programming paradigm using [http://en.wikipedia.org/wiki/Object_(computer_science) "objects"]- the data structures which consists of data fields and methods together with their interactions to design the applications and computer programs. The programming techniques include features like [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance].
It is a type of programming language where the programmers define not only the data type of a structure but also the type of functions that can be applied to the data structure.

An example of the code from JAVA language is as follows:

<code>
Class HelloWorld
{
public static void main(String args[])
{
System.out.println("Hello world!"):
System.out.println("Arguments you have entered is:");
if (args.length>0)
{
for(int i=0;i<args.length;i++)
{
System.out.print(args[i]+" ");
}
System.out.println();
}
else
System.out.println("<<No Arguments>>");
}
}
</code>

===Features===
*'''[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]:''' Inheritance establishes relationships among [http://en.wikipedia.org/wiki/Class_(computer_science) classes] where it helps the [http://en.wikipedia.org/wiki/Object_(computer_science) objects] to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

*'''[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation]:''' Encapsulation is defined as the process of binding or wrapping the data and the code that operates on the data into a single entity. This keeps the data safe from outside interface and misuse.

*'''[http://en.wikipedia.org/wiki/Data_abstraction Data Abstraction]:''' Data abstration is the development of [http://en.wikipedia.org/wiki/Class_(computer_science) classes], [http://en.wikipedia.org/wiki/Object_(computer_science) objects], types in terms of their [http://en.wikipedia.org/wiki/Interface_(computer_science) interfaces] and functionality, instead of their implementation details. Abstraction can denote a model, a view, or some other focused representation for an actual item and is used to manage complexity.

*'''[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]:''' The concept of polymorphism can be explained as "one [http://en.wikipedia.org/wiki/Interface_(computer_science) interface], multiple [http://en.wikipedia.org/wiki/Method_(computer_science) methods]". Polymorphism enables one entity to be used as as general category for different types of actions and there are two basic types of polymorphism. Overridding, also called run-time polymorphism and Overloading, which is referred to as compile-time polymorphism.

===Advantages===

*Simulates real-world event much more effectively
*[http://en.wikipedia.org/wiki/Code Code] is reusable thus less code may have to be written
*[http://en.wikipedia.org/wiki/Data Data] becomes active
*Better ability to create GUI (graphical user interface) applications
*Ability to reach their goals faster
*Programmers are able to produce faster, more accurate and better-written applications

===Limitations===

*Best suited for dynamic, interactive environments but becomes complicated for systems that don't require so much complexity.
* OOP provides only one representation (object-oriented).
* Although OOP technology allows the creation of reusable components, programmers may not know what reusable components already exist, how to access them, how to understand them, and how to combine, adapt, and modify them to meet current needs.

==Transition from Block Structured to OO Programming?==
===History===
Before the emergence of block structured programming,programmers used to write their code as a continuous stretch of code that extended line after line without any organized structure. This approach was tedious in terms of understanding,debugging and maintaining. This lead to the developement of structural programming.

The principle idea behind structured programming was the idea of divide and conquer. A computer program was considered as a set of tasks and any task that is too complex to be described simply would be broken down into a set of smaller component tasks, until the tasks were sufficiently small and self-contained enough that they were easily understood. This was termed as the top-down method and was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: [http://en.wikipedia.org/wiki/Fortran FORTRAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/ALGOL ALGOL],[http://en.wikipedia.org/wiki/C_(programming_language) C] etc.

[http://en.wikipedia.org/wiki/Block_(programming) Block-Structured programming] remained an enormously successful approach for dealing with complex problems until the late 1980s, when the size of programs increased and some of the deficiencies of structured programming had become evident.Some of these problems included:

*In this type of methodology as the emphasis is on functions, as the actions became more involved or abstract, the functions grew to be more complex.

*Hierarchical structuring for data and procedures produced cumbersome code with large amounts of "tramp data"

*Usage of global subprogram names and variables was recognized dangerous.

*Also, a small change, such as requesting a user-chosen new option (text font-color) could cause a massive ripple-effect with changing multiple subprograms to propagate the new data into the program's hierarchy.

===Why OOP?===

[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming] was developed to respond to these needs, providing techniques for managing enormous complexity, achieving reuse of software components, and coupling data with the tasks that manipulate that data.Object Oriented programming paradigm used "[http://en.wikipedia.org/wiki/Object_(computer_science) objects]" which were considered to be [http://en.wikipedia.org/wiki/Data_structure data structures] consisting of data fields and [http://en.wikipedia.org/wiki/Method_(computer_science) methods] together with their interactions. It also took the concept of [http://en.wikipedia.org/wiki/Subroutine subroutines] into a completely different zone.

The main advantage of object oriented programming over other languages is that they enable programmers to create modules that need not be changed when a type of object is added. Software objects model real world objects and so the complexity is reduced and the program structure becomes very clear. The main features that make the object oriented better are modifiability, extensibility, maintainability, portability, scalability and reusability. Modifiability ensures that it is easy to make minor changes in the data representation or the procedures in an OO program. And any changes inside the class will not affect any other part of a program. Extensibility is adding new features or responding to changing operating environments by introducing new objects and modifying some existing ones. Maintanability is the feature where the objects can be maintained and the problems can be fixed easier. Reusability is a very important feature where the objects can be reused in different programs.
This makes OOP efficient for more complicated and flexible interactions. For many systems, an OO approach can speed development time since many objects are standard across systems and can be reused.

Its programming techniques included features such as [http://en.wikipedia.org/wiki/Data_abstraction data abstraction], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], [http://en.wikipedia.org/wiki/Message_passing messaging], [http://en.wikipedia.org/wiki/Module_(programming) modularity], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] which changed the face of programming for many people.
Some of the most commonly used [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming languages] are: [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/Java_(programming_language) Java] etc..

==Comparision between Block Structured and OO Programming==

'''Block-Structured languages vs. Object-oriented languages'''

{| class="wikitable" border="1"
|-
! Properties
! Block-Structured languages
! Object-oriented languages
|-
| '''Primary focus'''
| The focus is around the data structures and subroutines. The subroutines are where actually where stuff happens and data structures are just the containers of the data required by the subroutines.
| The primary focus of object-oriented programming is on the data itself. Here the types are designed first and then come up with the operations needed to work with them.
|-
| '''Approach'''
| Block Structured languages follow a Top-down approach.
| Object Oriented languagues follow a Bottom-up approach.
|-
| '''Program design'''
| It is complex since the procedure orientation forces the designer to map the real-world problems to features of the programming language.
| It is simpler because the object orientation allows the designer to work with a much higher level conceptual model of the real-world problem.
|-
| '''Data Protection'''
| These languages do not prohibit a code that directly accesses global data, and local variables are not very useful for representing data that must be accessed by many functions.
| Object-Oriented languages enforce "hiding" of data declared private in a class which can be accessed externally only through the public member functions of that class.
|-
| '''Creation of new data types'''
| It is tedious at the language level if the language does not support OOP.
| It is easily accomplished at this language level by defining a new class for the data type.
|-
| '''Dynamic Binding'''
| Instance variables, static variables, static overridden methods and overloaded methods are all bound at compile time.
| OOP enables polymorphism in which objects belonging to different types respond to method, field, or property calls of the same name, each one according to an appropriate type-specific behavior. So the exact behavior is determined at run-time (called late binding or dynamic binding).
|-
| '''Comprehension of the program'''
| Rigorous due to poor equivalence between the program variables and physical entities
| More apparent due to the close match between program classes and real-world classes.
|-
| '''Modularity'''
| Not as good since data structures and functions are not linked.
| Better since related data and functions are placed in the same module.
|-
| '''Complexity'''
| Simple to understand small programs but gets complicated when the code gets large.
| Easy to understand but can get complex in some cases by unnecessary abstraction.
|-
| '''Maintainance and extension of the program'''
| Requires high degree of knowledge of the entire program.
| Convenient due to enhanced modularity of the program.
|-
| '''Reusability of code'''
| Difficult to reuse since submodules are generally coded to satisfy specific needs of a higher level module
| Easy to use the existing classes without modification by deriving sub classes with additional items and functions required for specific application
|-
| '''Examples'''
| C, ALGOL 60, PASCAL are examples of block-structured languages.
| C++ and JAVA are examples of object-oriented languages.
|}

==Usage of Block Structures in Object Oriented Programming==
In most programming languages, a statement can be either a simple statement (a simple instruction ending with a semicolon) or a compound statement (several instructions grouped in a block). In the case that we want the statement to be a simple statement, we do not need to enclose it in braces ({}). But in the case that we want the statement to be a compound statement it must be enclosed between braces ({}), forming a block. A block is a group of statements separated by a semicolon(;) but grouped together in a block enclosed in braces : {}:

The basic building blocks of object oriented languages are considered as objects and classes. Class is the building block that encapsulates both data and functionality. The blocks in object oriented languages are used to concisely represent some code that would typically be written with loops in some other languages by using looping constructs such as 'if-else', 'while', 'for' etc.. in JAVA. Blocks allow control structure to be implemented using messages and polymorphism. Blocks are used to implement user-defined control structures, enumerators, visitors, pluggable behavior and many other patterns. In any object oriented language, all the programs are designed around functions or block of statements which manipulate data. These languages allow the programmers to think in terms of building blocks that are closer to what program actually will do. The well known programming quality criteria are programming speed, error correction speed, computation speed, readability and portability and the importance of a hierarchical description of systems. The use of encapsulation, inheritance and polymorphism fulfill the previously mentioned criteria without the need to incorporate complex kernels to control data flows. The block structure enables recycling blocks of program code. Once a block of program code is written, it can be reused in any number of programs unlike traditional programming. The methods which represent the operations are declared in the class blocks and the methods are implemented in the method blocks.

Let us now see the usage of blocks in some Object Oriented Languages:
In Ruby, closure is called a block.
In an object instance variable (denoted with '@'), remember a block:

<code>
def remember(&a_block)
@block = a_block
end
</code>

Invoke the above method, giving it a block which takes a name:

<code>
remember {|name| puts "Hello, #{name}!"}
</code>

When the time is right (for the object) -- call the closure:

<code>
@block.call("Jon")
</code>

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

<code>
array = [1, 'hi', 3.14]
array.each {|item| puts item }
</code>
*1
*'hi'
*3.14

<code>
array.each_index {|index| puts "#{index}: #{array[index]}" }
</code>

*1
*'hi'
*3.14

'''Usage of blocks in CPP:'''

C++ also uses blocks in many situations like in conditional structures like if and else.
The if keyword is used to execute a statement or block only if a condition is fulfilled. Its form is:

if (condition) statement

Where condition is the expression that is being evaluated. If this condition is true, statement is executed. If it is false, statement is ignored (not executed) and the program continues right after this conditional structure.
For example, the following code fragment prints x is 100 only if the value stored in the x variable is indeed 100:

<code>
if (x == 100)
cout << "x is 100";
</code>

If we want more than a single statement to be executed in case that the condition is true we can specify a block using braces { }:

<code>
if (x == 100)
{
cout << "x is ";
cout << x;
}
</code>

Hence, as seen above blocks form an integral part of programming practice in most of the languagues, but the importance given to the blocks and functions or to the data depends based on the paradigm used.

==Conclusion==
Thus we can say that though these languages have their own advantages, Object oriented languages are preferred for the present scenario because of the above seen features.

==See Also==
*[http://www.scribd.com/doc/35821664/Programming-Paradigms Programming Paradigms]
*[http://web.eecs.utk.edu/~huangj/CS302S04/notes/oo-intro.html History of OOP]
*[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding]
*[http://en.wikipedia.org/wiki/Function_overloading Function Overloading]
*[http://en.wikipedia.org/wiki/Method_overriding Method Overriding in Inheritance]
*[http://en.wikipedia.org/wiki/Comparison_of_programming_languages Comparison of Programming languages]
*[http://en.wikipedia.org/wiki/Structured_programming Structured Programming]

==References==
* http://en.wikipedia.org/wiki/Block_(programming) Block Programming
* http://bulletin.sigchi.org/1997/october/papers/ross/ Structured Programmers Learning Object-Oriented Programming
* http://www.cplusplus.com/doc/tutorial/control/ C++
* http://askville.amazon.com/Compare-Contrast-Structured-programming-Object-Oriented/AnswerViewer.do?requestId=2470573 Contrast Structured and OOP
* http://www.cs.rpi.edu/~szymansk/OOF90/F90_Objects.html
* http://janeataylor.wordpress.com/2005/12/02/structured-vs-object-oriented-programming/ Structured vs Object Oriented Programming
* http://www.ibiblio.org/g2swap/byteofpython/read/oops.html
* http://www.delphibasics.co.uk/Article.asp?Name=OO Object Oriented Overview
* http://www.triconsole.com/php/oop.php
* http://www.wisegeek.com/what-is-structured-programming.htm What is Structured Programming
* http://ascelibrary.org/cpo/resource/1/jccee5/v18/i3/p226_s1 Object-Oriented Paradigm in Programming for Computer-Aided Analysis of Structures
* http://expressionflow.com/category/object-oriented-programming/intro-to-oop-in-labview/
* http://dl.acm.org/citation.cfm?id=36164 Block Structure and Object Oriented Languages
* http://en.wikipedia.org/wiki/Smalltalk Smalltalk
* http://drhanson.s3.amazonaws.com/storage/documents/blockstructure.pdf Is Block Structure Necessary?
* http://www.php-developer.org/learn-php-oop-object-oriented-programming-for-beginners-tutorial/ PHP