CSC/ECE 517 Fall 2011/ch1 1e lm

Introduction

This wiki article discusses two things viz the effectiveness & durability of object oriented languages (like Java, Python, etc) as compared to block structured languages(like C, Pascal, Algol etc) and how block structure can be leveraged in an object oriented language.

Block structured languages

Definition

A block is a piece of code consisting of one or more declarations and statements. A block structured programming language is the one that would allow usage of such blocks & including nesting of such blocks. The purpose of blocks is to allow a group of statements to be treated as one.For instance, you might want to have a block of statements which does matrix multiplication.Blocks also narrow the lexical scope of the variables, procedures & functions declared in a block so that they don’t conflict with others(which might be used for a totally different purpose)having the same name elsewhere in the program.For instance, you might want to have a local variable “count” to count the sum of some variables whereas you might have another local variable with the same name “count” to count the number of elements in an array.

Basic features

• Tasks are accomplished using functions. The primary focus is on functions. It involves creating a list of instructions and grouping them into blocks.
• The functions share global data. The data is stored in data structures which act as information containers. These are global in scope and are passed around between functions using parameters.
• It uses a top down approach of program design. Here the system is broken down into sub-systems which are recursively refined into additional sub- system levels until we reach base level of granularity which can be implemented by a single function.
• Functions are implemented as black-boxes with an input and output specification.

Examples

Some of the examples of these languages include Algol, C & Pascal.

• E.g. Pascal program multiply two numbers

Here we can see that the block is delimited by "Begin" & "End" keywords

Program Multiplication_Of_Two_Numbers;

Var Product, Multiplier, Multiplicand : Real; 

Begin
    Writeln('Program to multiply 2 numbers:');
    Writeln;
    Writeln;
    Write('Enter the Multilicand: ');
    Readln(Multiplicand);
    Writeln;
    Write('Enter the Multiplier: ');
    Readln(Multiplier);
   
    Product := Multiplicand * Multiplier;
    Writeln;
    Writeln('Product of ',Multiplicand,'and ',Multiplier,'equals '+
           +'to ',Product);

End.

• E.g. C program to read a file line by line

#include<stdio.h>

void main()
{
      FILE *ifp = fopen("C:\Users\Challenge\Documents\Glossary.txt", "r"); /*File pointer which takes as input the file "Glossary.txt"*/ 
      char line[80];                                                       /*Assuming each line is 80 character in length*/

      
      while(fgets(line,1,sizeof(line),fp)                                  /*Loop till no more lines to read*/
      {
            printf("%s", line);                                            /*Prints this line on to the standard output*/
      }
      fclose(fp);                                                          /*Closes the file*/
}

Object Oriented Languages:

Definition

Object oriented languages are built on the object oriented concept. This is the programming paradigm that bundles the data and the methods that access and manage this data into single entity called an Object. This bundling of data and methods allows the object to act as a single entity and have a fluid interface through which it can interact with the outside world. The objects are generally modeled on real world objects.

Fundamental features of Object Oriented languages

• Object/Class: Class consists of tightly coupled data fields and set of operations that act on the data. The entire set of data and operations represent a user-defined data type. An object is an instance of a class. Thus a class acts as a collection of objects of similar type. Multiple objects may be created out of a class. The objects may share the operations of the class but have their own set of data fields. An object can be defined by its current state (current value of its data members) and its behavior (the methods that can be called on the object).

• Data Abstraction/Encapsulation: The wrapping of data and functions into a single unit (class) is called encapsulation. Encapsulation protects an object from accidental modifications by an external entity since data fields can be accessed only through predetermined interfaces. Encapsulation is implemented using language constructs like private, public, protected, etc. Abstraction involves representing only the essential features of the object and hiding the background details. Classes provide abstraction by hiding the data attributes and providing functions that provide a controlled view of the object to an external entity.

• Inheritance: Inheritance is the ability of a class to inherit partly or completely the features of another class. It allows the hierarchical classification of objects.For example, the bird Peacock is a part of the class Flying bird which again is part of the class Bird. Inheritance allows the reusability of code. Pre-existing classes can be reused by extending them and adding new functionality to create sub classes without modifying the original classes. The sub class will then have the combined features of both classes. This allows a programmer to tailor a new class from an existing class without introducing any undesirable side effects in the base classes.

• Interface: Interface is an abstract type containing no data but only a list of method definitions. A class that has all the methods defined in the interface is said to have implemented the method interface. Interfaces allow classes to define how they will communicate with an external entity. By implementing an interface, a class promises an external entity using the interface that it will provide the functionality specified by the interface.

• Polymorphism/Dynamic Binding: This is the ability of a variable, method or an object to take more than one forms. This enables an objects of different types to respond to same method or property call but in its own type specific way. For example consider overloading the + operator, so that when called on strings, it concatenates the strings while for numbers it adds them up. Polymorphism also allows objects with different internal structures to share the same external interface. This helps in dynamic binding. Dynamic binding means that the code executed for a given function call is not known until actual runtime. For example, in a dynamically typed language a variable can hold an object irrespective of its data type. Hence a function call associated with a reference (variable) depends on the dynamic type of that reference (variable) i.e. the current object referenced by the variable.

Examples

The below languages implement different degrees of OO features

• Ruby, Scala, Smalltalk, Eiffel are said to be purely OO languages. Here even primitives are implemented as OO objects.
• Java, C# , VB.NET, Python are OO languages but have some degree of procedural elements
• Visual Basic, PHP, Perl are basically procedural languages with some OO features.

Need for Object Oriented Languages

Block structured languages follow a task-centric approach rather than a data-centric approach. This resulted in certain flaws:

1. Structured programming follows a hierarchy of structures. However in large programs data is generally in the form of a network of structures. This resulted in a lot of tramp data being passed around.<ref> Object Oriented Comparison. Web. 8 June 2011. </ref>
2. As the program size increased the amount of data being passed around increased proportionately. Ensuring parameters are correctly passed to the correct subprogram becomes a major issue.
3. In case of large programs even a small change resulted in massive ripple-effect with changing multiple sub modules to propagate the new data through the program's hierarchy.
4. Structured program shared a lot of global data. The acces to the data was uncontrolled and unpredictable. There was no control over who had access to what.
5. Structured program suffered from memory leaks. This was because anyone could create global structures and there was no responsibility on the creator to deallocate the memory.

The main motivating factor for object-oriented approach is to remove these flaws of block structured languages. OO languages treat data as a critical element and do not allow it to flow freely around the system. The data is tied to the functions with operate on and prevent it from accidental modification from external functions.

Advantages of Object-oriented languages over Block structured languages<ref>Balaguruswamy, E. Object Oriented Programming with C++. New Delhi: Tata Mcgraw-Hill, 2008. Print.</ref>

1. Object oriented approach follows a data centered approach. It is possible to map objects in the problem domain to those in the program. This helps the programmer visualize the program in terms of real world objects and which leads to a much better design. Also it allows more details of a model to be captured in implementable form.
2. The principle of data hiding helps in building secure programs. The data fields of an object can be accessed only through the interface defined by its publicly accessible methods. Such controlled access prevents any inadvertent change to object data by external modules.
3. Mapping real world entities into objects help reduce and easily manage software complexity . Also it helps when systems need to be upgraded to larger systems.
4. Objects act as black boxes with internal structure and well defined interfaces. Hence adding new functionality becomes easier, since we can easily isolate the objects/classes that need to be modified or extended. The low coupling between objects allows an object to be modified without any effect on the other objects accessing it so long as the interface through which they interact remain untouched.
5. Most modern object oriented languages provides a load of class libraries and frameworks. These are much easier to use as compared to library functions present in block structured languages. The frameworks help in rapid software development and easier testing and debugging thus leading to increased productivity.
6. Message passing techniques (ex: interfaces in JAVA) help separate implementation of an object from its externally visible interface. Multiple classes of objects may implement the same interface. In such cases an object can be replaced by another object without affecting external entities dependent on that object so long as the interface is untouched. This results in low coupling.
7. Object oriented design provides much better memory management. Recent OO languages sport automated garbage handling. Even for languages without garbage collection, memory deallocation of data members can be handled in the destructors of the objects. But in case of block structured languages (like C), it is the programmers responsibility to take care of releasing the dynamically allocated memory. Also the data structures tend to be global in scope and persist beyond the scope of the functions calling them. Hence it becomes difficult to fix responsibility on functions to deallocate them. This leads to memory leaks.

Drawbacks of Object-Oriented Languages

Although object oriented languages sport some very advantageous features as compared to block structured languages, they do have some drawbacks.

1. Economy of language features: The addition of OO features to a language and the additional syntax needed to implement these features makes it bulky. The complexity of these languages make them daunting to learn and master.<ref name="badEnggProperties">Bad Engineering Properties of Object-Oriented Languages by Luca Cardelli</ref>
2. Economy of execution: OO style is intrinsically less efficient as compared to block structured style. In procedural languages, type checking occurs at compile time. Hence no tests are needed at runtime for pointer dereferencing for method calls.In OO style each routine is supposed to be a virtual method. This introduces indirections in the form of method tables during for dereferencing. <ref name="badEnggProperties">Bad Engineering Properties of Object-Oriented Languages by Luca Cardelli</ref>
3. Also many OO languages include automatic garbage collection. This along with the overhead of creation and destruction of objects degrades performance in resource intensive systems such as embedded systems and real time systems.<ref>Object Oriented Vs Procedural Programming in Embedded System </ref>

Usage of block-structures in Object Oriented languages

OO languages have evolved from block structured languages. Though OO languages use the concepts of class and objects,inheritance,etc they inherently still rely on a blocks to define the structure of the code. The key areas where OO languages assimilate the idea of block structure include:

• In classes the member functions or methods are implemented using blocks. Each method can be viewed as a block that accepts parameters from an external entity that calls it, performs some processing (that may or may not require the use of data fields of the object) and returns control back with or without a return value.
• Blocks are also useful in defining control structures like loops, conditional blocks(e.g. if...else), etc.

E.g. a for loop in Java

int a=10, result =0;
for (int i : a)
{
      result += i;
      return result;
}

• OO languages generally provide inbuilt language support for exception handling. Most OO languages implement exception handling in terms of blocks

E.g.: Try...catch blocks in Java Here the catch and finally blocks are used to delimit a group of statements that can be called to handle exceptions at runtime

try{
    System.out.println("Inside try block of testMethod!");
    i = 100/0;
}
catch(Exception e){
    System.out.println("Inside catch block of testMethod!");
    System.out.println(“Caution: your trying to Divide a number by Zero...”);
}
finally{
    System.out.println("Inside finally block of testMethod!");
    System.out.println(“This block executes everytime an exception is caught...”);
}

• Certain OO languages like JAVA allow creation of anonymous classes which are basically blocks which don’t have a name but can be instantiated without actually making a separate class.

E.g. Here ActionListener is an interface which has been implemented as anonymous block in the below JAVA example

button1a.addActionListener(new ActionListener(){
       public void actionPerformed (ActionEvent event){
              // Figure out how to make this work
              //sim.runCastleCrash();
       }
});

• In a pure OO language like Ruby, blocks can also be used to defines closures(blocks, procs & lambdas)<ref>Sosinski, Robert. "Understanding Ruby Blocks, Procs and Lambdas." N.p., 21 Dec. 2008. Web. 8 Sept. 2011.</ref>

E.g. Given below is a method which yields control to a block in Ruby & also passes parameter to it at the same time.

def block_demo
 yield("Smith")
end

block_demo { |name| puts " Hello #{name} " }

The Output will be
 Hello Smith 

Conclusion

Block structured languages had their uses in earlier days when code size was small and the main focus was on efficiency(in terms of space & memory) of programs. However, these programs could not scale in size as maintenance and code complexity became an overhead.

Object Oriented concepts like encapsulation, inheritance(which helps in code re-usability), interfaces & polymorphism allowed better visualization of the software problem and its design to handle this complexity. Moreover, class libraries and frameworks developed in these languages helped abstract the code complexity and allowed rapid program development. This led to a gradual transition from block oriented to object oriented languages for application development.

References

<references/>

See Also

1. Block(programming)
2. Structured Programming
3. Object-oriented design
4. Object-oriented programming

External Links

1. Object Oriented Concepts (Java Tutorials)
2. Block Structure and Object Oriented Languages by Ole Lehrmann Madsen
3. A Tutorial on Algol 68, by Andrew S. Tanenbaum, in Computing Surveys, Vol. 8, No. 2, June 1976, with Corrigenda (Vol. 9, No. 3, September 1977)
4. Official Ruby Webpage