CSC/ECE 517 Fall 2010/ch1 1e vs

CSC/ECE 517 Fall 2010/ch1 1e vs

---

Introduction

This article mainly compares and contrasts Block-Structured languages and Object-Oriented languages and also focuses on the advantages of Object-Oriented languages over Block-structured languages. 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 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: ALGOL,PASCAL,FORTRAN etc.. Block structured languages have a syntax such that the structures are enclosed within the bracketed keywords like if....fi in ALGOL language.

An example of a block in ALGOL looks as shown below:

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

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 "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 data abstraction, encapsulation, messaging, polymorphism and 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:

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>>");
   } 
}

Features

• Inheritance: Inheritance establishes relationships among classes where it helps the objects to work together and makes it easy to extend existing structures to produce new structures with slightly different behavior.

• 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.

• Data Abstraction: Data abstration is the development of classes, objects, types in terms of their 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.

• Polymorphism: The concept of polymorphism can be explained as "one interface, multiple 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
• Code is reusable thus less code may have to be written
• 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.

Why transition from Block Structured to Object Oriented 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 methodand was found to be adequate for coding moderately extensive programs. Some examples of structured programming languages are: FORTRAN, Pascal, ALGOL,C etc.

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?

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 "objects" which were considered to be data structures consisting of data fields and methods together with their interactions. It also took the concept of 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 chnages 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 can be solved 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 data abstraction, encapsulation, messaging, modularity, polymorphism, and inheritance which changed the face of programming for many people. Some of the most commonly used object-oriented programming languages are: C++, Java etc..

Comparision between Block Structured Languages and Object Oriented Languages

Block-Structured languages vs. Object-oriented languages

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.
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.
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.
Approach	Block Structured languages follow a Top-down approach.	Object Oriented languagues follow a Bottom-up approach.
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:

def remember(&a_block)
 @block = a_block
end

Invoke the above method, giving it a block which takes a name:

remember {|name| puts "Hello, #{name}!"}

When the time is right (for the object) -- call the closure:

@block.call("Jon")

=> "Hello, Jon!"

Iterating over enumerations and arrays using blocks:

array = [1, 'hi', 3.14]
array.each {|item| puts item }

• 8
• 'hi'
• 3.14

array.each_index {|index| puts "#{index}: #{array[index]}" }

• 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:

 if (x == 100)
 cout << "x is 100";

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 { }:

if (x == 100)
{
  cout << "x is ";
  cout << x;
}

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.